Changes in / [8291293:398e8e9]

File:

• examples/hashtable2.cfa (modified) (16 diffs)

examples/hashtable2.cfa

@@ -32 +32 @@
 DATA_EXCEPTION(ht_fill_limit_crossed)(
         void * theHashtable;
-    bool want_throwResume_ht_auto_resize_pending;
-    size_t size_for_ht_auto_resize_pending;
 );
 
@@ -39 +37 @@
         VTABLE_INIT(this, ht_fill_limit_crossed);
         this.theHashtable = theHashtable;
-    this.want_throwResume_ht_auto_resize_pending = false;
-    this.size_for_ht_auto_resize_pending = 0;
 }
 
@@ -49 +45 @@
 VTABLE_INSTANCE(ht_fill_limit_crossed)(ht_fill_limit_crossed_msg);
 
-
-DATA_EXCEPTION(ht_auto_resize_pending)(
-        void * theHashtable;
-    size_t new_size;
-);
-
-void ?{}(ht_auto_resize_pending & this, void * theHashtable, size_t new_size) {
-        VTABLE_INIT(this, ht_auto_resize_pending);
-        this.theHashtable = theHashtable;
-    this.new_size = new_size;
-}
-
-const char * ht_auto_resize_pending_msg(ht_auto_resize_pending * this) {
-        return "ht_auto_resize_pending";
-}
-
-VTABLE_INSTANCE(ht_auto_resize_pending)(ht_auto_resize_pending_msg);
 
 
@@ -96 +75 @@
         size_t item_count;
         float ff_next_warn_up;
-        float ff_warn_step_factor;
 
         void (*defaultResumptionHandler) (ht_fill_limit_crossed &);
@@ -106 +84 @@
 forall( otype Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
 
-    void ?{}( hashtable_rbs(Tt_unused) & this, size_t n_buckets, dlist(request_in_ht_by_src, request) *buckets,
-        float ff_next_warn_up, float ff_warn_step_factor ) {
-
-        printf( "base hashtable ctor with %ld buckets at %p\n", n_buckets, buckets);
+    void ?{}( hashtable_rbs(Tt_unused) & this, size_t n_buckets, dlist(request_in_ht_by_src, request) *buckets ) {
 
         this.n_buckets = n_buckets;
@@ -115 +90 @@
 
         this.item_count = 0;
-        this.ff_next_warn_up = ff_next_warn_up;
-        this.ff_warn_step_factor = ff_warn_step_factor;
+        this.ff_next_warn_up = 0.5;
 
         this.defaultResumptionHandler = defaultResumptionHandler;
@@ -124 +98 @@
         }
     }
-
-    void ?{}( hashtable_rbs(Tt_unused) & this, size_t n_buckets, dlist(request_in_ht_by_src, request) *buckets ) {
-        printf( "base hashtable ctor with default warning steps\n" );
-        ( this ) { n_buckets, buckets, 0.5, 2 };
-    }
-
-}
-
-// this fwd declaration is artifact of workaround trac#192
-void defaultResumptionHandler( ht_auto_resize_pending & ex );
+}
+
 
 forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) {
@@ -160 +126 @@
     void check_ff_warning( hashtable_rbs(Tt_unused) & this ) with (this) {
         if (fill_frac(this) > ff_next_warn_up) {
-            ht_fill_limit_crossed ex1 = { &this };
-            throwResume ex1;
-            // workaround trac#192: want the second throwResume to be in __dynamic_defaultResumptionHandler
-            // ... want base hashtable decoupled from resize
-            if ( ex1.want_throwResume_ht_auto_resize_pending ) {
-                throwResume( (ht_auto_resize_pending) { & this, ex1.size_for_ht_auto_resize_pending } );
-            }
+            throwResume (ht_fill_limit_crossed){ &this };
         }
     }
@@ -210 +170 @@
 
 void defaultResumptionHandler(ht_fill_limit_crossed & ex) {
+    printf("default resumption ht_fill_limit_crossed\n");
     hashtable_rbs(t_unused) & ht = *(hashtable_rbs(t_unused) *)ex.theHashtable;
-    printf("base default resumption handler ht_fill_limit_crossed with ht filled at %f\n", fill_frac(ht));
-    ht.ff_next_warn_up *= ht.ff_warn_step_factor;
+    ht.ff_next_warn_up *= 2;
 }
 
@@ -232 +192 @@
     struct hashtable_rbs_dynamic { 
         inline hashtable_rbs(Tt_unused);
-
-        struct resize_policy {
-            // When fill factor exceeds grow limit, grow big enough for
-            // resulting fill factor to be lower than grow_target.  Vice versa.
-            // Using different grow and shrink limits prevents noisy current
-            // size from triggering grow-shrink oscillation.  OK to use same
-            // grow and shrink targets.
-            float grow_limit, shrink_limit, grow_target, shrink_target;
-
-            // warn with exception but do nothing, this many -1 times, then actually resize
-            unsigned short int warns_per_grow, warns_per_shrink;
-
-            // Don't shrink below.
-            size_t nbuckets_floor;
-        } policy;
-
         dlist(request_in_ht_by_src, request) * (*alloc)( size_t );
         void (*free)( void * ); 
@@ -265 +209 @@
 forall( otype Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) {
 
-    void ?{}( hashtable_rbs_dynamic(Tt_unused).resize_policy & this, size_t nbuckets_floor ) {
-        printf("default dynamic policy ctor\n");
-
-        (this.grow_limit)      {2.0};
-        (this.shrink_limit)    {0.5};
-        (this.grow_target)     {1.0};
-        (this.shrink_target)   {1.0};
-        (this.warns_per_grow)  {4};
-        (this.warns_per_shrink){4};
-        (this.nbuckets_floor)  {nbuckets_floor};
-    }
-
-    void ?{}( hashtable_rbs_dynamic(Tt_unused) & this, size_t n_buckets, hashtable_rbs_dynamic(Tt_unused).resize_policy rp )  {
-        printf("ctor hashtable_rbs_dynamic{ size_t, resize_policy }\n");
-
-        float first_first_warn_up = rp.grow_target;
-        float ff_warn_step_factor = (rp.grow_limit / rp.grow_target) \ ( 1. / rp.warns_per_grow );
-
+    void ?{}( hashtable_rbs_dynamic(Tt_unused) & this, size_t n_buckets )  {
         void (*defaultResumptionHandler) (ht_fill_limit_crossed &) = __dynamic_defaultResumptionHandler;
         dlist(request_in_ht_by_src, request) *buckets = alloc(n_buckets);
-        ( ( hashtable_rbs( Tt_unused ) & ) this ){ n_buckets, buckets, first_first_warn_up, ff_warn_step_factor };
-        ( this.policy ){ rp };
+        ((hashtable_rbs(Tt_unused) &)this){ n_buckets, buckets };
         this.alloc = alloc;
         this.free = free;
-    }
-    void ?{}( hashtable_rbs_dynamic(Tt_unused) & this, hashtable_rbs_dynamic(Tt_unused).resize_policy rp )  {
-        printf("ctor hashtable_rbs_dynamic{ resize_policy }\n");
-        ( this ) { rp.nbuckets_floor, rp };
-    }
-    void ?{}( hashtable_rbs_dynamic(Tt_unused) & this, size_t n_buckets )  {
-        printf("ctor hashtable_rbs_dynamic{ size_t }\n");
-        ( this ) { n_buckets, (hashtable_rbs_dynamic(Tt_unused).resize_policy){ n_buckets } };
     }
     void ^?{}( hashtable_rbs_dynamic(Tt_unused) & this ) {
@@ -312 +230 @@
         // make empty hash table of new size
         dlist(request_in_ht_by_src, request) *oldBuckets = buckets;
-        float oldFfWarnStepFactor = ff_warn_step_factor;
-        float newFfNextWarnUp = ((float)item_count) / ((float) new_n_buckets);
         ^?{}( (hashtable_rbs(Tt_unused) &)this );
         free( oldBuckets );
-        ?{}( (hashtable_rbs(Tt_unused) &)this, new_n_buckets, alloc(new_n_buckets), newFfNextWarnUp, oldFfWarnStepFactor );
+        ?{}( (hashtable_rbs(Tt_unused) &)this, new_n_buckets, alloc(new_n_buckets) );
 
         // fill new table with old items
@@ -331 +247 @@
 }
 
-void defaultResumptionHandler( ht_auto_resize_pending & ex ) {
-    hashtable_rbs_dynamic(t_unused) & ht = *(hashtable_rbs_dynamic(t_unused) *)ex.theHashtable;
-    printf("auto-resize unhandled: proceeding with resize\n");
-    rehashToLarger_STEP( ht, ex.new_size );
-}
-
 void __dynamic_defaultResumptionHandler(ht_fill_limit_crossed & ex) {
     hashtable_rbs_dynamic(t_unused) & ht = *(hashtable_rbs_dynamic(t_unused) *)ex.theHashtable;
-    printf("dynamic warning received with fill_frac = %f and buckets at %p\n", fill_frac(ht), ht.buckets);
-    if ( fill_frac( ht ) >= ht.policy.grow_limit ) {
-        float grow_amount =  ht.policy.grow_limit / ht.policy.grow_target;
-        ex.want_throwResume_ht_auto_resize_pending = true;
-        ex.size_for_ht_auto_resize_pending = ( size_t )( grow_amount * ht.n_buckets );
-    } else {
-        // base handler, not specialized for dynamic
-        defaultResumptionHandler( ex );
-    }
+    printf("dynamic limit crossed with fill_frac = %f and buckets at %p\n", fill_frac(ht), ht.buckets);
+    rehashToLarger_STEP( ht, 2 * ht.n_buckets );
 }
 
@@ -357 +260 @@
 #include <stdlib.hfa>
 
-void basicFillingTestHelper( hashtable_rbs(t_unused) & ht, size_t n_elems ) {
-
-    request & wasnt_found = get(ht, 17);
+int main() {
+
+
+    HASHTABLE_RBS_STATIC(67, h_src)
+
+    request & wasnt_found = get(h_src, 17);
     assert( &wasnt_found == 0p );
 
@@ -366 +272 @@
     r.tgt_id = 998;
 
-    put(ht, r);
-
-    request & found = get(ht, 117);
+    put(h_src, r);
+
+    request & found = get(h_src, 117);
     assert( &found == &r );
 
-    & wasnt_found = & get(ht, 998);
+    & wasnt_found = & get(h_src, 998);
     assert( &wasnt_found == 0p );
 
-    request rs[n_elems];
-    for (i; n_elems) {
-        rs[i].src_id = 8000 * i;
-        put(ht, rs[i]);
-    }
-
-    assert(  & get(ht, 117      ) );
-    assert(  & get(ht, 8000*25  ) );
-    assert(! & get(ht, 8000*25+1) );
-}
-
-void basicFillingTest_static() {
-
-    printf("---start basic fill test static ----\n");
-
-    HASHTABLE_RBS_STATIC(67, ht)
-
-    basicFillingTestHelper(ht, 500);
-}
-
-void basicFillingTest_dynamic() {
+    printf( "%f\n", fill_frac(h_src) );
+
+
+    request rs[500];
+    try {
+        for (i; 500) {
+            rs[i].src_id = 8000 * i;
+            put(h_src, rs[i]);
+        }
+    } catchResume(ht_fill_limit_crossed*) {
+        printf("fill limit tripped with h_src filled at %f\n", fill_frac(h_src));
+        throwResume;
+    }
+
+    assert(  & get(h_src, 117      ) );
+    assert(  & get(h_src, 8000*25  ) );
+    assert(! & get(h_src, 8000*25+1) );
+
+
 
     dlist(request_in_ht_by_src, request) * (*old_alloc)( size_t ) = alloc;
@@ -409 +313 @@
     }
 
-    printf("---start basic fill test dynamic ----\n");
-
-    hashtable_rbs_dynamic(t_unused) ht = { 113 };
-
-    basicFillingTestHelper(ht, 500);
-}
-
-// Demonstrates user-provided instrumentation monitoring a fixed-size hash table
-void logTest() {
-
-    printf("---start log test ----\n");
-
-    HASHTABLE_RBS_STATIC(67, ht)
-
+    hashtable_rbs_dynamic(t_unused) ht2 = { 113 };
+    request rs2[500];
     try {
-        basicFillingTestHelper(ht, 500);
-    } catchResume( ht_fill_limit_crossed * ) {
-        printf("log test instrumentation runs\n");
+        for (i; 500) {
+            if (i % 10 == 0) {printf("%d(%f),", i, fill_frac(ht2));}
+            rs2[i].src_id = 8000 * i;
+            put(ht2, rs2[i]);
+        }
+    } catchResume(ht_fill_limit_crossed*) {
+        printf("fill limit tripped with ht2 filled at %f\n", fill_frac(ht2));
         throwResume;
     }
-}
-
-// Demonstrates "snoozing" a growing hash table's auto-resize event,
-// in that that next call to put will get the resize exception instead.
-void snoozeTest() {
-
-    printf("---start snooze test ----\n");
-
-    hashtable_rbs_dynamic(t_unused) ht = { 113 };
-
-    bool lastResizeSnoozed = false;
-
-    try {
-        basicFillingTestHelper(ht, 500);
-    } catchResume( ht_auto_resize_pending * ) {
-
-        if ( lastResizeSnoozed == false ) {
-            lastResizeSnoozed = true;
-            printf("snooze test intervention decides to snooze this time\n");
-        } else {
-            lastResizeSnoozed = false;
-            printf("snooze test intervention decides to allow the resize\n");
-            throwResume;
-        }
-
-    }
-}
-
-int main() {
-
-    basicFillingTest_static();
-    basicFillingTest_dynamic();
-
-    logTest();
-    snoozeTest();
-}
+
+
+}