p1 : Distributed Bitcoin Miner /640 9/26/16

Transcription

1 p1 : Distributed Bitcoin Miner /640 9/26/16

2 P0 Reference to last year s p0 will be posted Should be structurally identical

3 Timeline Part A Checkpoint (Due 10/4) Part A (Due 10/13) Part B (Due 10/20)

4 Part A: LSP Protocol You will implement the Live Sequence Protocol Has some features of both UDP and TCP + more

5 LSP Features client-server communication model can maintain multiple connections Communication is sent in discrete UDP-sized packets Messages are sent in order and exactly once

6 Messages Consist of: Message type : connect, data, or ack Connection ID : number that identifies the clientserver connection Sequence Number : number identifying the message s order Payload: sequence of bytes (the actual data)

7 Messages type MsgType int const ( MsgConnect MsgType = iota // Conn request from client. MsgData // Data message from client or server. MsgAck // Acknowledgment from client or server. ) type Message struct { Type MsgType // One of the message types listed above. ConnID int // Unique client-server connection ID. SeqNum int // Message sequence number. Payload []byte // Data message payload. }

8 Messages Messages are marshaled using Go s Marshal function in the json package and sent as a UDP packet

9 Establishing a Connection Client (Connect, 0, 0) Client begins by sending a connection request (must have ID 0 and sequence number 0)

10 Establishing a Connection Client (Connect, 0, 0) (Ack, id, 0) generates a unique identifier for this Client- connection (you can just generate ID s sequentially)

11 Sending data and Client maintain independent sequence numbers (Data, id, i, hello ) (Ack, id, i) (Data, id, i+1, hi ) Client (Ack, id, i+1) (Data, id, j, hi ) (Ack, id, j)

12 Maintaining Order UDP Packets aren t guaranteed to arrive in order LSP.Read()//blocks LSP.Read() LSP.Read()

13 Maintaining Order UDP Packets aren t (Data, id, i, 440 ) guaranteed to arrive in order LSP.Read()//returns 440 LSP.Read()//blocks LSP.Read()

14 Maintaining Order UDP Packets aren t (Data, id, i, 440 ) guaranteed to arrive in order (Data, id, i+2, fun ) LSP.Read()//returns 440 LSP.Read()//blocks LSP.Read() i + 2 : fun

15 Maintaining Order UDP Packets aren t (Data, id, i, 440 ) guaranteed to arrive in order (Data, id, i+2, fun ) LSP.Read()//returns 440 LSP.Read()//returns is LSP.Read()//returns fun (Data, id, i+1, is ) i + 2 : fun

16 Sliding Window Like TCP, LSP uses a sliding window protocol Given a window size ω, we can send up to ω messages without acknowledgement. If the oldest unacknowledged message has sequence number n, then only messages with sequence numbers n + ω - 1 (inclusive) may be sent

17 Sliding Window Client ω = 3 Client messages queue = h -> e -> l -> l -> o

18 Sliding Window Client ω = 3 (Data, id, i, h ) Client messages queue = e -> l -> l -> o Oldest Seq # without Ack = i Window = [i, i+2]

19 Sliding Window Client ω = 3 Client messages queue = l -> l -> o (Data, id, i, h ) (Data, id, i+1, e ) Oldest Seq # without Ack = i Window = [i, i+2]

20 Sliding Window Client ω = 3 Client messages queue = l -> o (Data, id, i, h ) (Data, id, i+1, e ) (Data, id, i+2, l ) Oldest Seq # without Ack = i Window = [i, i+2]

21 Sliding Window Client ω = 3 Client messages queue = l -> o Oldest Seq # without Ack = i (Data, id, i, h ) (Data, id, i+1, e ) (Data, id, i+2, l ) block Window = [i, i+2]

22 Sliding Window Client ω = 3 Client messages queue = l -> o Oldest Seq # without Ack = i (Data, id, i, h ) (Data, id, i+1, e ) (Data, id, i+2, l ) (Ack, id, i+1) Window = [i, i+2]

23 Sliding Window Client ω = 3 Client messages queue = l -> o Oldest Seq # without Ack = i Window = [i, i+2] (Data, id, i, h ) (Data, id, i+1, e ) (Data, id, i+2, l ) (Ack, id, i+1) block

24 Sliding Window Client ω = 3 Client messages queue = l -> o Oldest Seq # without Ack = i+2 Window = [i+2, i+4] (Data, id, i, h ) (Data, id, i+1, e ) (Data, id, i+2, l ) (Ack, id, i+1) (Ack, id, i)

25 Sliding Window Client ω = 3 Client messages queue = (Data, id, i, h ) (Data, id, i+1, e ) (Data, id, i+2, l ) Oldest Seq # without Ack = i+2 Window = [i+2, i+4] (Ack, id, i+1) (Ack, id, i) (Data, id, i+3, l ) (Data, id, i+4, o )

26 Epoch events We still need to deal with dropped packets On both the clients and servers, we have a simple time trigger to fire epoch events periodically. Epoch events should fire at a fixed rate, with time between epochs = δ. When an epoch event fires, clients and server take actions in case of dropped packets or lost connection

27 Client Epoch Actions If connection request has not been acknowledged, resend connection (Connect, 0, 0) Client request } δ (Connect, 0, 0) (Ack, id, 0) (Connect, 0, 0)

28 Client Epoch Actions For every unacknowledged data message sent, resend (Data, id, i, data ) Client (Data, id, i+1, dayda ) (Ack, id, i+1) } δ (Data, id, i, data ) (Data, id, i+1, dayda ) Note that message i+1 is duplicated on the server

29 Client Epoch Actions If no data message has been received since the last epoch, send ack with sequence number 0 (Data, id, j, hi ) (Ack, id, j) Client } δ (Ack, id, 0)

30 Epoch Actions Similarly on the server, for each client connection For each data message that has been sent, but not yet acknowledged, resend the data message If no data message has been received from the client, then send an ack with sequence number 0

31 Epoch events Notice this design ensures that at least one message is transmitted in each direction between client and server on every epoch We can keep track of epochs passed since the last message was received. If this goes over a limit K, we can assume the connection is lost

32 Checkpoint (due 10/4) Assume no packet loss (no need to implement epoch) Messages sent in order No need to implement sliding window protocol Race conditions will not be checked

33 Checkpoint (due 10/4) Client (Data, id, i, hello ) (Ack, id, i) A simple read/write server (Data, id, i+1, hi ) Pretty much implement this picture (Ack, id, i+1) (Data, id, j, hi ) (Ack, id, j)

34 What you ll be writing client_impl.go func NewClient(hostport string, params *Params) (Client, error) *should block until connection with server is established ConnID() int *returns connection ID Read() ([]byte, error) *blocks until data is received and ready to be returned or if connection is lost Write(payload []byte) error *should never block Close() error *blocks until all pending messages are sent and acked, or if connection is lost

35 What you ll be writing server_impl.go func New(port int, params *Params) (, error) *should not block Read() (int, []byte, error) *should block until data is received from some client and is ready to be returned or if connection is lost Write(connID int, payload []byte) error *should not block CloseConn(connID int) error *should not block Close() error *blocks until all pending messages are sent and acked, or if connection is lost

36 lspnet Contains every UDP operation needed. net package is not allowed! import github.com/cmu440/lspnet addr, err := lspnet.resolveudpaddr("udp", hostport) udpconn, err := lspnet.listenudp("udp", addr) n, cliaddr, err := udpconn.readfromudp(buffer[0]:) udpconn.writetoudp(msg, cliaddr)

37 Implementation notes Individual project No locks and mutexes There s no limit on message queue size, so don t use buffered channel to store pending messages. Instead use something like linked list

38 Bitcoin miner Goal: given a message M and an unsigned integer N, find unsigned integer n which when concatenated with M generates the smallest hash value, for all 0 n N. This n is called the nonce This takes a long time for large values of N. Instead, distribute more manageable workloads

39 Bitcoin miner Client message, N minhash, n message, 0, N/2 minhash, n message, N/2, N minhash, n Miner Miner