Unneeded socketSend() wait for W5x00 to complete send reduces transmit throughput by 75%

[SapientHetero]

While investigating puzzling differences between transmit and receive throughput I found the following design flaw.

socketSend() writes the data to be transmitted to one of the W5x00's circular socket buffers, then waits for the W5x00 to finish transmitting the data before returning. Waiting is unnecessary because the next socketSend() call checks for available space in the socket's circular buffer before sending more data, and it eliminates the advantage of the W5x00 being able to send the data without interacting with the processor.

Removing the wait by deleting the following lines increases W5500 transmit throughput by a whopping 4X on my Adafruit Metro M4/W5500 Shield webserver with no impact on reliability. I don't have W5100 or W5200 devices to test with but based on documentation review I see no reason this improvement won't work on them too.

/* +2008.01 bj */
while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK ) {
	/* m2008.01 [bj] : reduce code */
	if ( W5100.readSnSR(s) == SnSR::CLOSED ) {
		EthernetClass::spi()->endTransaction();
		return 0;
	}
	EthernetClass::spi()->endTransaction();
	yield();
	EthernetClass::spi()->beginTransaction(SPI_ETHERNET_SETTINGS);
}
/* +2008.01 bj */
W5100.writeSnIR(s, SnIR::SEND_OK);

[ladyada]

@per1234 hiya do you know if there's anyone at Arduino that is doing maintenance/merges for arduino libraries? last release for this one was 2 yrs ago, but the product is still sold https://store.arduino.cc/products/arduino-ethernet-shield-2

[SapientHetero]

I also noticed that the current socketsend() implementation inefficiently waits until the W5x00 socket circular buffer has room for the entire input buffer before writing to it. As a result, the processor does no productive work while waiting. The modified code addressing both this and the transmit wait enhancement is below. An improved version of the library including numerous bug fixes and new features, tested with W5500, is available at https://github.com/SapientHetero/Ethernet

`uint16_t EthernetClass::socketSend(uint8_t s, const uint8_t* buf, uint16_t len)
{
uint8_t status = 0;
uint16_t ret = 0;
uint16_t freesize = 0; // empty bytes in W5500 circular buffer
uint16_t remblock = 0; // remaining bytes to be sent after partial buffer write
uint32_t start;

if (len > W5100.SSIZE) {
	ret = W5100.SSIZE; // check size not to exceed MAX size.
}
else {
	ret = len;
}

// read circular buffer free space
SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
freesize = getSnTX_FSR(s);									// currently available space in socket n's circular write buffer
status = W5100.readSnSR(s);
SPI.endTransaction();
remblock = ret;											// initialize remblock to buffer length

// if any free space is available, start.
if (freesize < remblock) {									       // if all "len" bytes can't be written...
	if (freesize > 0) {									       //  but some space is available...
		SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
		write_data(s, 0, (uint8_t*)buf, freesize);			// make use of wait time by writing all that will fit, then write the rest when there's room
		W5100.writeSnIR(s, (SnIR::SEND_OK | SnIR::TIMEOUT));// clear SnIR SEND_OK and TIMEOUT bits before starting next send
		W5100.execCmdSn(s, Sock_SEND);                                       // SEND command sets Socket Tx read pointer to TX write pointer value
		SPI.endTransaction();
		remblock = ret - freesize;							// number of bytes that won't currently fit in circular buffer
	}
// now wait for more space in circular buffer
	start = millis();										// record time loop is entered +rs 17Feb2019
	do {
		SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
		freesize = getSnTX_FSR(s);
		status = W5100.readSnSR(s);
		SPI.endTransaction();
		if ((status != SnSR::ESTABLISHED) && (status != SnSR::CLOSE_WAIT) || millis() - start > 1000)		// todo - implement user-configurable _timeout
			return ret - remblock;
		yield();
	} while (freesize < remblock);							// loop until there's enough space or timeout occurs (in case peer process crashes without closing socket) +rs
}

// when space is available, write remainder of data
SPI.beginTransaction(SPI_ETHERNET_SETTINGS);
write_data(s, 0, (uint8_t*)(buf+len-remblock), remblock);
W5100.writeSnIR(s, (SnIR::SEND_OK | SnIR::TIMEOUT));		// clear SnIR SEND_OK and TIMEOUT bits before starting next send+rs 18May2025
W5100.execCmdSn(s, Sock_SEND);
SPI.endTransaction();

return ret;

}`