Most of the new myriad api is in.

Still to go: bootstrapping reading the initial header, saving the
header, growing streams as we write?

1 files changed, 136 insertions, 7 deletions

diff --git a/src/stable/myriad.cpp b/src/stable/myriad.cpp
index 5278ac5..f3ff09a 100644
--- a/src/stable/myriad.cpp
+++ b/src/stable/myriad.cpp
@@ -81,6 +81,14 @@ bool Bu::Myriad::setSize( Bu::Myriad::StreamId /*iStream*/,
     return false;
 }
 
+Bu::String Bu::Myriad::getLocation() const
+{
+    Bu::MutexLocker l( mAccess );
+    Bu::MutexLocker l2( mBacking );
+    return Bu::String("myriad(%1,%2):%3")
+        .arg( 1 ).arg( iBlockSize ).arg( rBacking.getLocation() );
+}
+
 bool Bu::Myriad::loadMyriad()
 {
     Bu::println("Load myriad!");
@@ -264,6 +272,32 @@ int32_t Bu::Myriad::allocateBlock()
     }
 }
 
+void Bu::Myriad::releaseBlock( int32_t iBlockId, bool bBlank )
+{
+    Bu::MutexLocker l( mAccess );
+    lFreeBlocks.append( iBlockId );
+    if( bBlank )
+    {
+        blankBlock( iBlockId );
+    }
+}
+
+void Bu::Myriad::blankBlock( int32_t iBlockId )
+{
+    Bu::MutexLocker l( mBacking );
+    rBacking.setPos( iBlockId*iBlockSize );
+    int32_t iChunk = std::min( iBlockSize, 4096 );
+    uint8_t *pChunk = new uint8_t[iChunk];
+    memset( pChunk, 0, iChunk );
+    int iLeft = iBlockSize;
+    while( iLeft > 0 )
+    {
+        int32_t iWrite = rBacking.write( pChunk, std::min( iChunk, iLeft ) );
+        iLeft -= iWrite;
+    }
+    delete[] pChunk;
+}
+
 void Bu::Myriad::openStream( StreamId id )
 {
     Bu::MutexLocker l( mAccess );
@@ -276,20 +310,36 @@ void Bu::Myriad::closeStream( StreamId id )
     hStream.get( id )->close();
 }
 
-int32_t Bu::Myriad::blockRead( int32_t iStart, void *pTarget, int32_t iSize )
+int32_t Bu::Myriad::blockRead( int32_t iBlock, int32_t iStart,
+        void *pTarget, int32_t iSize )
 {
     int32_t iUpperSize = iBlockSize - (iStart%iBlockSize);
-    Bu::println("Max size within block: %1 vs %2  (start=%3, blocksize=%4)")
+    Bu::println("Max read within block: %1 vs %2  (start=%3, blocksize=%4)")
         .arg( iUpperSize ).arg( iSize )
         .arg( iStart ).arg( iBlockSize );
 
     int32_t iAmnt = std::min( iSize, iUpperSize );
     Bu::MutexLocker l( mBacking );
-    rBacking.setPos( iStart );
+    rBacking.setPos( iBlockSize*iBlock + iStart );
 
     return rBacking.read( pTarget, iAmnt );
 }
 
+int32_t Bu::Myriad::blockWrite( int32_t iBlock, int32_t iStart,
+        const void *pTarget, int32_t iSize )
+{
+    int32_t iUpperSize = iBlockSize - (iStart%iBlockSize);
+    Bu::println("Max write within block: %1 vs %2  (start=%3, blocksize=%4)")
+        .arg( iUpperSize ).arg( iSize )
+        .arg( iStart ).arg( iBlockSize );
+
+    int32_t iAmnt = std::min( iSize, iUpperSize );
+    Bu::MutexLocker l( mBacking );
+    rBacking.setPos( iBlock*iBlockSize + iStart );
+
+    return rBacking.write( pTarget, iAmnt );
+}
+
 /////////
 // Bu::Myriad::Stream
 //
@@ -308,22 +358,71 @@ Bu::Myriad::Stream::~Stream()
 {
 }
 
+int32_t Bu::Myriad::Stream::getSize() const
+{
+    Bu::MutexLocker l( mAccess );
+    return iSize;
+}
+
+int32_t Bu::Myriad::Stream::getBlockSize() const
+{
+    Bu::MutexLocker l( mAccess );
+    return rParent.iBlockSize;
+}
+
+Bu::Myriad::StreamId Bu::Myriad::Stream::getStreamId() const
+{
+    return iStream;
+}
+
+int32_t Bu::Myriad::Stream::getOpenCount() const
+{
+    Bu::MutexLocker l( mAccess );
+    return iOpenCount;
+}
+
+void Bu::Myriad::Stream::setSize( int32_t iNewSize )
+{
+    // Two possible modes, shrink or grow.
+    Bu::MutexLocker l( mAccess );
+    if( iNewSize < iSize )
+    {
+        // Shrink it
+        int iNewBlocks = Bu::blkDiv( iNewSize, rParent.iBlockSize );
+        while( aBlocks.getSize() > iNewBlocks )
+        {
+            rParent.releaseBlock( aBlocks.last(), false );
+            aBlocks.eraseLast();
+        }
+        iSize = iNewSize;
+    }
+    else if( iNewSize > iSize )
+    {
+        // Grow it
+        int iNewBlocks = Bu::blkDiv( iNewSize, rParent.iBlockSize );
+        while( aBlocks.getSize() < iNewBlocks )
+        {
+            aBlocks.append( rParent.allocateBlock() );
+        }
+        iSize = iNewSize;
+    }
+}
+
 int32_t Bu::Myriad::Stream::read( int32_t iStart, void *pTarget,
         int32_t iSize )
 {
-    int32_t iPos = iStart;
     int32_t iRead = 0;
     Bu::MutexLocker l( mAccess );
-    while( iStart > 0 )
+    while( iSize > 0 )
     {
         int32_t iBlock = aBlocks[iStart/rParent.iBlockSize];
-        int32_t iOffset = iPos % rParent.iBlockSize;
         int32_t iChunkRead = rParent.blockRead(
-                iBlock*rParent.iBlockSize+iOffset, pTarget, iSize
+                iBlock, iStart%rParent.iBlockSize, pTarget, iSize
                 );
         if( iChunkRead == 0 )
             break;
         iRead += iChunkRead;
+        iStart += iChunkRead;
         reinterpret_cast<ptrdiff_t &>(pTarget) += iChunkRead;
         iSize -= iChunkRead;
     }
@@ -331,6 +430,36 @@ int32_t Bu::Myriad::Stream::read( int32_t iStart, void *pTarget,
     return iRead;
 }
 
+int32_t Bu::Myriad::Stream::write( int32_t iStart, const void *pTarget,
+        int32_t iSize )
+{
+    int32_t iWrite = 0;
+    Bu::MutexLocker l( mAccess );
+    while( iSize > 0 )
+    {
+        int32_t iBlockIdx = iStart/rParent.iBlockSize;
+        int32_t iBlock = aBlocks[iBlockIdx];
+        int32_t iChunkWrite = rParent.blockWrite(
+                iBlock, iStart%rParent.iBlockSize, pTarget, iSize
+                );
+        if( iChunkWrite == 0 )
+            break;
+        iWrite += iChunkWrite;
+        iStart += iChunkWrite;
+        reinterpret_cast<ptrdiff_t &>(pTarget) += iChunkWrite;
+        iSize -= iChunkWrite;
+    }
+
+    return iWrite;
+}
+
+Bu::String Bu::Myriad::Stream::getLocation() const
+{
+    Bu::MutexLocker l( mAccess );
+    return Bu::String("%1:stream %2")\
+        .arg( rParent.getLocation() ).arg( iStream );
+}
+
 void Bu::Myriad::Stream::open()
 {
     Bu::MutexLocker l( mAccess );