private unsafe void _PollImpl(TrinityMessage poll_req) { m_mod.SendMessage(m_client, poll_req.Buffer, poll_req.Size, out var poll_rsp); var sp = PointerHelper.New(poll_rsp.Buffer + poll_rsp.Offset); //HexDump.Dump(poll_rsp.ToByteArray()); //Console.WriteLine($"poll_rsp.Size = {poll_rsp.Size}"); //Console.WriteLine($"poll_rsp.Offset = {poll_rsp.Offset}"); var payload_len = poll_rsp.Size - TrinityProtocol.TrinityMsgHeader; if (payload_len < sizeof(long) + sizeof(int)) { throw new IOException("Poll response corrupted."); } var errno = *(sp.ip - 1); try { if (errno == 2) { Log.WriteLine(LogLevel.Warning, $"{nameof(TrinityClient)}: server drops our connection. Registering again."); RestartPolling(); return; } if (errno != 0) { return; } var pctx = *sp.lp++; var msg_len = *sp.ip++; if (msg_len < 0) { return; // no events } MessageBuff msg_buff = new MessageBuff { Buffer = sp.bp, BytesReceived = (uint)msg_len }; MessageDispatcher(&msg_buff); // !Note, void-response messages are not acknowledged. // Server would not be aware of client side error in this case. // This is by-design and an optimization to reduce void-response // message delivery latency. In streaming use cases this will be // very useful. try { if (pctx != 0) { _PostResponseImpl(pctx, &msg_buff); } } finally { Memory.free(msg_buff.Buffer); } } finally { poll_rsp.Dispose(); } }
public PersistedCellEnumerator(byte[] content, long target_lowKey, long target_highKey) { m_content = content; m_length = content.Length; m_target_lowKey = target_lowKey; m_target_highKey = target_highKey; m_handle = GCHandle.Alloc(content, GCHandleType.Pinned); m_bp = (byte *)m_handle.AddrOfPinnedObject().ToPointer(); m_sp = PointerHelper.New(m_bp); m_ep = m_bp + m_length; }
private unsafe TrinityMessage _AllocPollMsg(int myInstanceId, int myCookie) { int msglen = sizeof(int) + sizeof(int) + TrinityProtocol.MsgHeader; byte * buf = (byte *)Memory.malloc((ulong)msglen); PointerHelper sp = PointerHelper.New(buf); *sp.ip = msglen - TrinityProtocol.SocketMsgHeader; *(TrinityMessageType *)(sp.bp + TrinityProtocol.MsgTypeOffset) = TrinityMessageType.SYNC_WITH_RSP; *(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.PollEvents; sp.bp += TrinityProtocol.MsgHeader; *sp.ip++ = myInstanceId; *sp.ip++ = myCookie; return(new TrinityMessage(buf, msglen)); }
private unsafe void PostResponse_impl(SynReqArgs args) { /****************************** * Protocol: PostResponse * Request: |4B InstanceId|4B Cookie|8B p| TrinityResponse | * Response: VOID ******************************/ PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset); int instanceId = *sp.ip++; int cookie = *sp.ip++; long p = *sp.lp++; var stg = CheckInstanceCookie(cookie, instanceId); stg.PostResponse_impl(p, sp.bp, args.Size - sizeof(int) * 2 - sizeof(long)); }
internal static bool GetCommunicationModuleOffset(this IMessagePassingEndpoint storage, string moduleName, out ushort synReqOffset, out ushort synReqRspOffset, out ushort asynReqOffset, out ushort asynReqRspOffset) { /****************** * Comm. protocol: * - REQUEST : [char_cnt, char[] moduleName] * - RESPONSE: [int synReqOffset, int synReqRspOffset, int asynReqOffset, int asynReqRspOffset] * An response error code other than E_SUCCESS indicates failure of remote module lookup. ******************/ using (TrinityMessage tm = new TrinityMessage( TrinityMessageType.PRESERVED_SYNC_WITH_RSP, (ushort)RequestType.GetCommunicationModuleOffsets, size: sizeof(int) + sizeof(char) * moduleName.Length)) { PointerHelper sp = PointerHelper.New(tm.Buffer + TrinityMessage.Offset); *sp.ip++ = moduleName.Length; BitHelper.WriteString(moduleName, sp.bp); TrinityResponse response; storage.SendMessage(tm, out response); bool ret = (response.ErrorCode == TrinityErrorCode.E_SUCCESS); if (ret) { sp.bp = response.Buffer + response.Offset; int synReq_msg = *sp.ip++; int synReqRsp_msg = *sp.ip++; int asynReq_msg = *sp.ip++; int asynReqRsp_msg = *sp.ip++; synReqOffset = (ushort)synReq_msg; synReqRspOffset = (ushort)synReqRsp_msg; asynReqOffset = (ushort)asynReq_msg; asynReqRspOffset = (ushort)asynReqRsp_msg; } else { synReqOffset = 0; synReqRspOffset = 0; asynReqOffset = 0; asynReqRspOffset = 0; } response.Dispose(); return(ret); } }
private unsafe void RedirectMessage_impl(SynReqArgs args) { /****************************** * Protocol: RedirectMessage * Request: |4B PartitionId| TrinityMessage | * Response: VOID * * Redirects the message to another instance. ******************************/ PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset); int partitionId = *sp.ip++; TrinityMessage tm = new TrinityMessage(sp.bp, (*sp.ip) + TrinityProtocol.SocketMsgHeader); m_memorycloud[partitionId].SendMessage(tm); }
private unsafe void RedirectMessage_impl(SynReqArgs args) { /****************************** * Protocol: RedirectMessage * Request: |4B InstanceId| TrinityMessage | * Response: VOID * * Redirects the message to another instance. ******************************/ PointerHelper sp = PointerHelper.New(args.Buffer + args.Offset); int instanceId = *sp.ip++; TrinityMessage tm = new TrinityMessage(sp.bp, *sp.ip + sizeof(int)); m_memorycloud[instanceId].SendMessage(tm); }
private unsafe void UpdateCell_impl(SynReqRspArgs args) { /****************************** * Protocol: UpdateCell * Request: |8B CellId|4B Size| Payload | * Response: [ 4B TrinityErrorCode header ] ******************************/ var sp = PointerHelper.New(args.Buffer + args.Offset); var id = *sp.lp++; var size = *sp.ip++; var err = (int)m_memorycloud.UpdateCell(id, sp.bp, size); var buf = (byte *)Memory.malloc(TrinityProtocol.MsgHeader); sp = PointerHelper.New(buf); *sp.ip++ = TrinityProtocol.MsgHeader - TrinityProtocol.SocketMsgHeader; *sp.ip = err; args.Response = new TrinityMessage(buf, TrinityProtocol.MsgHeader); }
public unsafe void SendMessage(byte *message, int size, out TrinityResponse response) { byte * header = stackalloc byte[TrinityProtocol.MsgHeader + sizeof(int)]; byte **bufs = stackalloc byte *[2]; int * sizes = stackalloc int[2]; bufs[0] = header; bufs[1] = message; sizes[0] = TrinityProtocol.MsgHeader + sizeof(int); sizes[1] = size; PointerHelper sp = PointerHelper.New(header); *sp.ip = size + sizeof(int) + TrinityProtocol.TrinityMsgHeader; *(sp.bp + TrinityProtocol.MsgTypeOffset) = (byte)TrinityMessageType.SYNC_WITH_RSP; *(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.RedirectMessageWithResponse; *(int *)(sp.bp + TrinityProtocol.MsgHeader) = partitionId; m_mod.SendMessage(m_ep, bufs, sizes, 2, out response); }
public unsafe TrinityErrorCode LoadCell(long cellId, out byte[] cellBuff, out ushort cellType) { using (var req = new __CellIdStructWriter(cellId)) { TrinityResponse rsp = null; TrinityErrorCode errcode = TrinityErrorCode.E_RPC_EXCEPTION; cellBuff = null; cellType = 0; try { var sp = PointerHelper.New(req.buffer); *sp.ip++ = TrinityProtocol.TrinityMsgHeader + sizeof(long); *sp.sp++ = (short)TrinityMessageType.SYNC_WITH_RSP; *sp.sp++ = (short)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.LoadCell; m_mod.SendMessage(m_ep, req.buffer, req.BufferLength, out rsp); sp = PointerHelper.New(rsp.Buffer); errcode = (TrinityErrorCode)(*sp.ip++); if (errcode == TrinityErrorCode.E_SUCCESS) { var length = *sp.ip++; cellType = (ushort)(*sp.sp++); cellBuff = new byte[length]; fixed(byte *p = cellBuff) { Memory.memcpy(p, sp.bp, (ulong)length); } } /* otherwise, fails with returned error code */ } finally { rsp?.Dispose(); } return(errcode); } }
public unsafe void SendMessage(byte **_bufs, int *_sizes, int count, out TrinityResponse response) { byte * header = stackalloc byte[TrinityProtocol.MsgHeader + sizeof(int)]; ulong bufs_len = (ulong)(sizeof(byte *) * (count + 1)); ulong sizes_len = (ulong)(sizeof(int) * (count + 1)); byte **bufs = (byte **)Memory.malloc(bufs_len); int * sizes = (int *)Memory.malloc(sizes_len); bufs[0] = header; sizes[0] = TrinityProtocol.MsgHeader + sizeof(int); Memory.memcpy(bufs + 1, _bufs, bufs_len); Memory.memcpy(sizes + 1, _sizes, sizes_len); PointerHelper sp = PointerHelper.New(header); *sp.ip = sizeof(int) + TrinityProtocol.TrinityMsgHeader + Utils._sum(_sizes, count); *(sp.bp + TrinityProtocol.MsgTypeOffset) = (byte)TrinityMessageType.SYNC_WITH_RSP; *(ushort *)(sp.bp + TrinityProtocol.MsgIdOffset) = (ushort)TSL.CommunicationModule.TrinityClientModule.SynReqRspMessageType.RedirectMessageWithResponse; *(int *)(sp.bp + TrinityProtocol.MsgHeader) = partitionId; m_mod.SendMessage(m_ep, bufs, sizes, count + 1, out response); }
public static InMemoryDataChunk New(IEnumerable <CellInfo> cells, int estimated_size) { MemoryStream ms = new MemoryStream(estimated_size); byte[] buf = new byte[sizeof(long) + sizeof(ushort) + sizeof(int)]; byte[] buf_cell = new byte[1024]; long lowkey = 0, highkey = 0; int size = 0; fixed(byte *p = buf) { foreach (var cell in cells) { if (size == 0) { lowkey = cell.CellId; } highkey = cell.CellId; PointerHelper sp = PointerHelper.New(p); *sp.lp++ = cell.CellId; *sp.sp++ = (short)cell.CellType; *sp.ip++ = cell.CellSize; ms.Write(buf, 0, buf.Length); while (buf_cell.Length < cell.CellSize) { buf_cell = new byte[buf_cell.Length * 2]; } Memory.Copy(cell.CellPtr, 0, buf_cell, 0, cell.CellSize); ms.Write(buf_cell, 0, cell.CellSize); size += cell.CellSize + buf.Length; } } byte[] payload = ms.GetBuffer(); Chunk chunk = new Chunk(lowkey, highkey); return(new InMemoryDataChunk(chunk, payload, lowkey, highkey)); }
private unsafe TrinityErrorCode _SendCellPayload(long cellId, byte *buff, int size, ushort?cellType, short msgId) { //header: cellId, size, type int header_len = TrinityProtocol.MsgHeader + sizeof(long) + sizeof(int) + (cellType.HasValue? sizeof(ushort): 0); byte * header = stackalloc byte[header_len]; byte ** holder = stackalloc byte *[2]; int * length = stackalloc int[2]; PointerHelper sp = PointerHelper.New(header); *sp.ip++ = header_len + size - TrinityProtocol.SocketMsgHeader; *sp.sp++ = (short)TrinityMessageType.SYNC_WITH_RSP; *sp.sp++ = msgId; *sp.lp++ = cellId; *sp.ip++ = size; if (cellType.HasValue) { *sp.sp++ = (short)cellType; } holder[0] = header; holder[1] = buff; length[0] = header_len; length[1] = size; TrinityResponse rsp = null; try { m_mod.SendMessage(m_ep, holder, length, 2, out rsp); return(*(TrinityErrorCode *)(rsp.Buffer)); } finally { rsp?.Dispose(); } }
internal static void GetCommunicationSchema(this IMessagePassingEndpoint storage, out string name, out string signature) { /****************** * Comm. protocol: * - REQUEST : VOID * - RESPONSE: [char_cnt, char[] name, char_cnt, char[] sig] ******************/ using (TrinityMessage tm = new TrinityMessage( TrinityMessageType.PRESERVED_SYNC_WITH_RSP, (ushort)RequestType.GetCommunicationSchema, size: 0)) { TrinityResponse response; storage.SendMessage(tm, out response); PointerHelper sp = PointerHelper.New(response.Buffer + response.Offset); int name_string_len = *sp.ip++; name = BitHelper.GetString(sp.bp, name_string_len * 2); sp.cp += name_string_len; int sig_string_len = *sp.ip++; signature = BitHelper.GetString(sp.bp, sig_string_len * 2); response.Dispose(); } }