anchor.diff:  
   interface VectorSink#(numeric type dsz, type a);
      interface PipeOut#(Bool) pipe;
  -   method Action start(DmaPointer h, Bit#(DmaOffsetSize) a, Bit#(DmaOffsetSize) l);
  +   method Action start(ObjectPointer h, Bit#(ObjectOffsetSize) a, Bit#(ObjectOffsetSize) l);
   endinterface
   interface DmaVectorSink#(numeric type dsz, type a);
  -   interface DmaWriteClient#(dsz) dmaClient;
  +   interface ObjectWriteClient#(dsz) dmaClient;
      interface VectorSink#(dsz, a) vector;
   endinterface
   
  
positive.code:    let abytes = asz / 8;
     let burstLen = 1;
  
     Bool verbose = True;
  
     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);
  
     interface DmaWriteClient dmaClient;
        interface Get writeReq;
  	  method ActionValue#(DmaRequest) 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 };
  	  endmethod
        endinterface : writeReq
        interface Get writeData;
  	 method ActionValue#(DmaData#(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 };
  	 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;
  	 endmethod
        endinterface : writeDone
     endinterface : dmaClient
  
     interface VectorSink vector;
         method Action start(DmaPointer h, Bit#(DmaOffsetSize) a, Bit#(DmaOffsetSize) l) if (doneoffset >= limit);
  	  pointer <= h;
  	  offset <= a*fromInteger(abytes);
  	  doneoffset <= a*fromInteger(abytes);
  
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;
  