Merge branch 'gcc-4.8' into gcc-4.7

ony · Apr 30, 2014 · 255a1c9 · 255a1c9
2 parents c90c3c3 + 3ecacc7
commit 255a1c9
Show file tree

Hide file tree

Showing 5 changed files with 89 additions and 15 deletions.
diff --git a/README.md b/README.md
@@ -21,7 +21,8 @@ Goals to stick with
 
 Notes for development
 ---------------------
-- tests should be run under valgrind also
+- tests should be run under valgrind also unless built with libasan (sanitizer
+  from gcc 4.8)
 
 Credits
 -------

diff --git a/include/leveldb/sandwich_db.hpp b/include/leveldb/sandwich_db.hpp
@@ -206,12 +206,19 @@ namespace leveldb
         void SeekToLast()
         {
             auto p = prefix;
-            p.next_net();;
-            impl.Seek(p);
-            if (impl.Valid())
-            { impl.Prev(); }
+            if (p == p.max())
+            {
+                impl.SeekToLast();
+            }
             else
-            { impl.SeekToLast(); }
+            {
+                p.next_net();;
+                impl.Seek(p);
+                if (impl.Valid())
+                { impl.Prev(); }
+                else
+                { impl.SeekToLast(); }
+            }
         }
         void Next() { impl.Next(); }
         void Prev() { impl.Prev(); }

diff --git a/include/leveldb/sequence.hpp b/include/leveldb/sequence.hpp
@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include <limits>
+
 #include <leveldb/any_db.hpp>
 
 namespace leveldb
@@ -62,6 +64,9 @@ namespace leveldb
         host_order<T> &operator--()
         { --value; return *this; }
 
+        static constexpr host_order<T> max()
+        { return std::numeric_limits<T>::max(); }
+
         // arithmetic in network order
         host_order<T> &next_net()
         {
@@ -126,15 +131,23 @@ namespace leveldb
         template <typename T1>
         Status Next(T1 &value)
         {
-            assert(next <= allocated);
+            assert( allocated == 0 || next <= allocated );
 
-            if (next == allocated)
+            if (allocated == 0) // noting allocated yet
             {
                 Status s = AllocPage();
                 if (!s.ok()) return s;
             }
 
-            value = next++;
+            if (next == allocated)
+            {
+                value = next++;
+                (void) AllocPage(); // pre-allocate next page for next request
+            }
+            else
+            {
+                value = next++;
+            }
             return Status::OK();
         }
 
@@ -151,6 +164,7 @@ namespace leveldb
                 if (allocated == 0) // initial (need to load prev value)
                 {
                     allocated = v;
+                    if (allocated == 0) return Status::NotFound("sequence overflow");
                     next = allocated;
                 }
                 else if (allocated != host_order<T>{v})
@@ -166,7 +180,13 @@ namespace leveldb
                 return s;
             }
 
-            const host_order<T> nextAllocated = allocated + PAGE_SIZE;
+            const host_order<T> nextAllocated = std::min(size_t(allocated.max()), allocated + PAGE_SIZE);
+            if (nextAllocated == allocated) // overflow
+            {
+                (void) base.Put(key, host_order<T>{0}); // mark as overflow
+                allocated = 0;
+                return Status::NotFound("meet sequence overflow");
+            }
             s = base.Put(key, nextAllocated);
             if (s.ok()) allocated = nextAllocated;
             return s;

diff --git a/test/simple.cpp b/test/simple.cpp
@@ -313,9 +313,7 @@ TEST(Simple, sequence)
     leveldb::MemoryDB db;
     short x;
 
-    vector<short> e;
-
-    leveldb::Sequence<short> a(db, "x");
+    leveldb::Sequence<unsigned short> a(db, "x");
     ASSERT_OK( a.Next(x) );
     EXPECT_EQ( 0, x );
     ASSERT_OK( a.Next(x) );
@@ -324,8 +322,8 @@ TEST(Simple, sequence)
 
     string v;
 
-    leveldb::Sequence<short> z(std::move(a));
-    leveldb::Sequence<short> b(db, "x");
+    leveldb::Sequence<unsigned short> z(std::move(a));
+    leveldb::Sequence<unsigned short> b(db, "x");
     EXPECT_OK( db.Get("x", v) );
     ASSERT_OK( b.Next(x) );
     EXPECT_EQ( 2, x ) << "In db " << PrintToString(v);

diff --git a/test/test_corners.cpp b/test/test_corners.cpp
@@ -19,6 +19,7 @@
 
 #include "leveldb/memory_db.hpp"
 #include "leveldb/whiteout_db.hpp"
+#include "leveldb/sandwich_db.hpp"
 #include "leveldb/txn_db.hpp"
 #include "leveldb/walker.hpp"
 
@@ -331,3 +332,50 @@ TEST(TestTxnIterator, txn_insert_next)
     ASSERT_TRUE( w.Valid() );
     EXPECT_EQ( "d", w.key() );
 }
+
+TEST(TestSequence, sequence_overflow)
+{
+    leveldb::MemoryDB db;
+    leveldb::Sequence<unsigned char> seq {db, "x"};
+    for(size_t n = 0; n < 0x100; ++n)
+    {
+        unsigned char x;
+        ASSERT_OK( seq.Next(x) );
+        EXPECT_EQ( n, x );
+    }
+    unsigned char overflow;
+    EXPECT_STATUS( NotFound, seq.Next(overflow) );
+}
+
+TEST(TestSandwichIterator, stuff_sandwich_to_overflow)
+{
+    leveldb::SandwichDB<leveldb::MemoryDB, unsigned char> sdb;
+    for(size_t n = 0; n < 0xff; ++n) // one part reserved for meta
+    {
+        SCOPED_TRACE("n=" + to_string(n));
+        decltype(sdb)::Cookie cookie;
+        ASSERT_OK( sdb.cook(to_string(n), cookie) )
+            << "Failed to allocate cookie #" << n;
+        auto db = sdb.use(cookie);
+        ASSERT_OK( db.Put("a", "first") );
+        ASSERT_OK( db.Put("b", "second") );
+        ASSERT_OK( db.Put("z", "last") );
+
+        auto w = leveldb::walker(db);
+
+        w.SeekToFirst();
+        ASSERT_TRUE( w.Valid() );
+        EXPECT_EQ( "a", w.key() );
+
+        w.Next();
+        ASSERT_TRUE( w.Valid() );
+        EXPECT_EQ( "b", w.key() );
+
+        w.SeekToLast();
+        ASSERT_TRUE( w.Valid() );
+        EXPECT_EQ( "z", w.key() );
+    }
+    decltype(sdb)::Cookie cookie;
+    ASSERT_STATUS( NotFound, sdb.cook("overflow", cookie) )
+        << "Allocated overflow as " << PrintToString(cookie);
+}