anchor.diff:     let abytes = asz / 8;
      let burstLen = 1;
   
  -   Bool verbose = True;
  +   Bool verbose = False;
   
      FIFOF#(Bool) rfifo <- mkFIFOF();
  -   Reg#(DmaPointer) pointer <- mkReg(0);
  -   Reg#(Bit#(DmaOffsetSize)) offset <- mkReg(0);
  -   Reg#(Bit#(DmaOffsetSize)) doneoffset <- mkReg(0);
  -   Reg#(Bit#(DmaOffsetSize)) limit <- mkReg(0);
  +   Reg#(ObjectPointer) pointer <- mkReg(0);
  +   Reg#(Bit#(ObjectOffsetSize)) offset <- mkReg(0);
  +   Reg#(Bit#(ObjectOffsetSize)) doneoffset <- mkReg(0);
  +   Reg#(Bit#(ObjectOffsetSize)) limit <- mkReg(0);
   
  -   interface DmaWriteClient dmaClient;
  +   interface ObjectWriteClient dmaClient;
         interface Get writeReq;
  -	  method ActionValue#(DmaRequest) get if (offset < limit && pipe_in.notEmpty());
  +	  method ActionValue#(ObjectRequest) get if (offset < limit && pipe_in.notEmpty());
   	     if (verbose) $display("DmaVectorSink writeReq h=%d offset=%h burstlen=%d pipein.notEmpty=%d rfifo.notFull=%d", pointer, offset, burstLen, pipe_in.notEmpty(), rfifo.notFull());
   	     offset <= offset + fromInteger(abytes)*burstLen;
  -	     return DmaRequest { pointer: pointer, offset: offset, burstLen: burstLen, tag: 0 };
  +	     return ObjectRequest { pointer: pointer, offset: offset, burstLen: burstLen, tag: 0 };
   	  endmethod
         endinterface : writeReq
         interface Get writeData;
  -	 method ActionValue#(DmaData#(asz)) get();
  +	 method ActionValue#(ObjectData#(asz)) get();
   	    let v = pipe_in.first;
   	    pipe_in.deq;
  -	    if (verbose) $display("DmaVectorSink.writeData offset=%h v=%h", offset, v);
  -
  -	    let da = doneoffset + fromInteger(abytes);
  -	    $display("DmaVectorSink writeDone da=%d limit=%d", da, limit);
  -	    if (da >= limit) rfifo.enq(?);
  -	    doneoffset <= da;
  -
  -	    return DmaData { data: pack(v), tag: 0 };
  +	    if (verbose) $display("DmaVectorSink.writeBack offset=%h v=%h", offset, v);
  +	    return ObjectData { data: pack(v), tag: 0 };
   	 endmethod
         endinterface : writeData
         interface Put writeDone;
   	 method Action put(Bit#(6) tag);
  -	    // let da = doneoffset + fromInteger(abytes)*burstLen;
  -	    // $display("DmaVectorSink writeDone tag=%h da=%d limit=%d", tag, da, limit);
  -	    // if (da >= limit) rfifo.enq(?);
  -	    // doneoffset <= da;
  +	    //$display("DmaVectorSink writeDone tag=%h", tag);
  +	    let da = doneoffset + fromInteger(abytes)*burstLen;
  +	    if (da >= limit)
  +	       rfifo.enq(?);
  +	    doneoffset <= da;
   	 endmethod
         endinterface : writeDone
      endinterface : dmaClient
   
      interface VectorSink vector;
  -       method Action start(DmaPointer h, Bit#(DmaOffsetSize) a, Bit#(DmaOffsetSize) l) if (doneoffset >= limit);
  +       method Action start(ObjectPointer h, Bit#(ObjectOffsetSize) a, Bit#(ObjectOffsetSize) l) if (doneoffset >= limit);
   	  pointer <= h;
   	  offset <= a*fromInteger(abytes);
   	  doneoffset <= a*fromInteger(abytes);
  
positive.code:       endinterface
     endinterface : bramClient
     interface VectorSource vector;
         method Action start(DmaPointer pointer, Bit#(DmaOffsetSize) a, Bit#(DmaOffsetSize) l) if (offset >= limit);
  	  if (verbose) $display("BramVectorSource.start a=%h l=%h", a, l);
  	  offset <= truncate(a);
  	  limit <= truncate(l);
  
negative.code: 
  interface VectorSource#(numeric type dsz, type a);
     interface PipeOut#(a) pipe;
     method Action start(ObjectPointer h, Bit#(ObjectOffsetSize) a, Bit#(ObjectOffsetSize) l);
  endinterface
  
  interface DmaVectorSource#(numeric type dsz, type a);
     interface ObjectReadClient#(dsz) dmaClient;
     interface VectorSource#(dsz, a) vector;
  endinterface
  
  function ObjectReadClient#(asz) getSourceReadClient(DmaVectorSource#(asz,a) s); return s.dmaClient; endfunction
  function ObjectWriteClient#(asz) getSinkWriteClient(DmaVectorSink#(asz,a) s); return s.dmaClient; endfunction
  function VectorSource#(dsz, dtype) dmaVectorSourceVector(DmaVectorSource#(dsz,dtype) dmavs); return dmavs.vector; endfunction
  
  module [Module] mkDmaVectorSource(DmaVectorSource#(asz, a))
     provisos (Bits#(a,asz),
  	     Div#(asz,8,abytes),
  	     Log#(abytes,ashift),
  	     Mul#(abytes, 8, asz)
  	     );
  
     Bool verbose = True;
  
     let asz = valueOf(asz);
     let abytes = valueOf(abytes);
     let ashift = valueOf(ashift);
     let burstLen = 1;
  
     FIFOF#(Bit#(asz)) dfifo <- mkFIFOF();
     MemreadEngine#(asz) memreadEngine <- mkMemreadEngine(2, dfifo);
  
     interface ObjectReadClient dmaClient = memreadEngine.dmaClient;
     interface VectorSource vector;
         method Action start(ObjectPointer p, Bit#(ObjectOffsetSize) a, Bit#(ObjectOffsetSize) l);
  	  if (verbose) $display("DmaVectorSource.start h=%d a=%h l=%h ashift=%d", p, a, l, ashift);
            memreadEngine.start(p, a, truncate(l << ashift), 8);
         endmethod
         interface PipeOut pipe;
  	  method first();
  	     return unpack(dfifo.first());
  	  endmethod
  	  method Action deq();
  	     if (verbose) $display("ObjectReadClient pipe.deq() data=%h", dfifo.first);
  	     dfifo.deq;
  	  endmethod
  	  method notEmpty = dfifo.notEmpty;
  