docs: static void remote_exec( final AutoBuffer ab ) {
      long lo = ab.get8(0), hi = ab.get8(8); // for dbg
      final int task = ab.getTask();
      final int flag = ab.getFlag();
      assert flag==CLIENT_UDP_SEND || flag==CLIENT_TCP_SEND; // Client-side send
      // Atomically record an instance of this task, one-time-only replacing a
      // null with an RPCCall, a placeholder while we work on a proper response -
      // and it serves to let us discard dup UDP requests.
      RPCCall old = ab._h2o.has_task(task);
      // This is a UDP packet requesting an answer back for a request sent via
      // TCP but the UDP packet has arrived ahead of the TCP.  Just drop the UDP
      // and wait for the TCP to appear.
      if( old == null && flag == CLIENT_TCP_SEND ) {
        if(ab.hasTCP())TimeLine.printMyTimeLine();
        assert !ab.hasTCP():"ERROR: got tcp with existing task #, FROM " + ab._h2o.toString() + " AB: " +  UDP.printx16(lo,hi);      // All the resends should be UDP only
        // DROP PACKET
      } else if( old == null ) {  // New task?
        RPCCall rpc;
        try {
          // Read the DTask Right Now.  If we are the TCPReceiver thread, then we
          // are reading in that thread... and thus TCP reads are single-threaded.
          rpc = new RPCCall(ab.get(water.DTask.class),ab._h2o,task);
        } catch( AutoBuffer.AutoBufferException e ) {
          // Here we assume it's a TCP fail on read - and ignore the remote_exec
          // request.  The caller will send it again.  NOTE: this case is
          // indistinguishable from a broken short-writer/long-reader bug, except
          // that we'll re-send endlessly and fail endlessly.
          Log.info("Network congestion OR short-writer/long-reader: TCP "+e._ioe.getMessage()+",  AB="+ab+", ignoring partial send");
          ab.drainClose();
          return;
        }
        RPCCall rpc2 = ab._h2o.record_task(rpc);
        if( rpc2==null ) {        // Atomically insert (to avoid double-work)
          if( (rpc._dt instanceof DRemoteTask || rpc._dt instanceof MRTask2) && rpc._dt.logVerbose() )
            Log.debug("Start remote task#"+task+" "+rpc._dt.getClass()+" from "+ab._h2o);
          H2O.submitTask(rpc);    // And execute!
        } else {                  // Else lost the task-insertion race
          if(ab.hasTCP())TimeLine.printMyTimeLine();
          assert !ab.hasTCP():"ERROR: got tcp with existing task #, FROM " + ab._h2o.toString() + " AB: " +  UDP.printx16(lo,hi); // All the resends should be UDP only
          // DROP PACKET
        }
      } else if( !old._computedAndReplied) {
        ++old._callCnt;
        // This packet has not been fully computed.  Hence it's still a work-in-
        // progress locally.  We have no answer to reply but we do not want to
        // re-offer the packet for repeated work.  Just ignore the packet.
        if(ab.hasTCP())TimeLine.printMyTimeLine();
        assert !ab.hasTCP():"ERROR: got tcp resend with existing in-progress task #, FROM " + ab._h2o.toString() + " AB: " +  UDP.printx16(lo,hi); // All the resends should be UDP only
        // DROP PACKET
      } else {
        ++old._ackResendCnt;
        if(old._ackResendCnt % 50 == 0)
          Log.err("Possibly broken network, can not send ack through, got " + old._ackResendCnt + " resends.");
        // This is an old re-send of the same thing we've answered to before.
        // Send back the same old answer ACK.  If we sent via TCP before, then
        // we know the answer got there so just send a control-ACK back.  If we
        // sent via UDP, resend the whole answer.
        if(ab.hasTCP())TimeLine.printMyTimeLine();
        assert !ab.hasTCP():"ERROR: got tcp with existing task #, FROM " + ab._h2o.toString() + " AB: " +  UDP.printx16(lo,hi); // All the resends should be UDP only
        old.resend_ack();
      }
      ab.close();
    }