tahoe | A Spring Framework based JavaEE application reference

Use margin-right instead of padding-right.

So! I had another stream that was running and it had the same parent directory as this stream.. this seems to have been a issue.

First stream was looking in: .start("/mnt/dev_stream/first_stream") Second stream was looking in: .start("/mnt/dev_stream/second_stream")

Editing the second stream to look in .start("/mnt/new_dev_stream/new_second_stream") fixed this issue!

Do not confuse the mean and the median:

the median is the value separating the higher half from the lower half of a population (wikipedia)

Note: your pictures are unreadable, please provide a higher resolution images

1. I don't think that algorithm is correct. A timer should be associated with each packet and stopped when ACK for this packet is received. Congestion control is triggered when the timer for any of the packets fires.

2. TCP is not exactly Go-Back-N receiver. In TCP receiver has a buffer too. This does not require any changes at the sender Go-Back-N. However, TCP is also supposed to implement flow control, in which the receiver tells the sender how much space in its buffer remains, and the sender adjusts its window accordingly.

3. Note, that Go-Back-N sequence number count packets, and TCP sequence numbers count bytes in the packets, you have to change your algorithm accordingly.

4. I would advice to get somewhat familiar with rfc793. It does not have congestion control, but it specifies how other TCP mechanics is supposed to work. Also this link has a nice illustration of TCP window and all variables associated with it.

My question is the Slow Start and Congestion Avoidance phase should happen right after if sendbase == nextseqnum? That is, right after confirming the receipt of an expected ACK?

your algorithm only does something when it receives ACK for the last packet. As I said, this is incorrect.

Regardless. Every ACK that acknowledges new packet shoult trigger window increase. You can do check this by checking if send_base was increased as the result of an ACK.

Dunno if every Tahoe implementation does this, but you may need this also. After three consequtive duplicate ACKs, i.e., ACKs that do not increase send_base you trigger congestion response.

My other question is about the Window Size, Go-Back-N uses a fixed window whereas TCP Tahoe uses a dynamic window. How can I calculate window size based on cwnd?

you make the N variable instead of constant, and assign congestion window to it.

in a real TCP with flow control you do N = min (cwnd, receiver_window).

Since the delta lake store in my case, had options('checkpoint','/_checkpoint') option enabled. The data reference was still available.

During development, after dropping the table and optimizing a using vaccum.

Thrift supports pluggable serialization schemes. In tree you have binary, compact and json. Out of tree anything goes. From the looks of it you are trying to decode compact protocol, so I'll answer accordingly.

Everything sent and everything returned in a Thrift RPC call is packaged in a struct. Every field in a struct has a 1 byte type and a 2 byte field ID prefix. In compact protocol field ids, when possible, are delta encoded into the type and all ints are compressed down to just the bits needed to store them (and some flags). Because ints can now take up varying numbers of bytes we need to know when they end. Compact protocol encodes the int bits in 7 bits of a byte and sets the high order bit to 1 if the next byte continues the int. If the high order bit is 0 the int is complete. Thus the int 5 (101) would be encoded in one byte as 0000101. Compact knows this is the end of the int because the high order bit is 0.

In your case, the int 134 (binary 10000110) will need 2 bytes to encode because it is more than 7 bits. The fist 7 bits are stored in byte 1 with the 0x80 bit set to flag "the int continues". The second and final byte encodes the last bit (00000001). What you thought was 134 was just the encoding of the first seven bits. The stray 1 was the final bit of the 134.

I'd recommend you use the in tree source to do any needed protocol encoding/decoding. It's already written and tested: https://github.com/apache/thrift/blob/master/lib/nodejs/lib/thrift/compact_protocol.js

I dont think your for iterates all the rows.
do this: for i in range(len(df)):
Also you can remove i = i + 1

You could create a filtering array containing all IDs from cars2 and use it to filter items in cars1 as follow:

try this its working