iperf | measure maximum TCP bandwidth , allowing the tuning

I am trying to run a Basic Publisher/Subscriber pair on the same Multicast/Port. It works perfectly when the hosts are connected to the same Switch, but not if the subscriber is on a different Switch.

Publisher

Simple application that scans Wi-Fi networks.

This one for a reference: Get available wi-fi scan result in customized listview

Just put a ListView in a layout and add ACCESS/CHANGE_WIFI_STATE permissions into manifest.

The problem is that it works on my Samsung J3 (2016), but I don't know why it doesn't on my new Samsung M11. Has it something to do with Android versions? I have already returned a Realme C3 that was having same issues because I thought it was due to Mediatek SOC.

SAMSUNG M11 (Android 10) LOG:

I want to deploy an Azure Ubuntu 18.04-LTS VM with a custom data file during an automation test, using tmplate.json and parameters.json files.

Although, the VM was deployed successfully, It seem that the custom data execution have failed and I do not understand why...

According to this link, cloud-init is available in the image that I use.

My template.json file contain:

I have a PHP array dd($iperfProfiles);

I have this code

I just started a course on Computer Networks and my first assignment provides me with mininet script of a simple star topology, and asks me run an iperf measurement between h1 and h2. While the iperf is running I should test the ping between h3 and h4.

My question is that how do I make iperf measuring the data to run in background so I can test the ping, as I can not input when the iperf is running also cant open new terminal for mininet.

The code for my scanner is below. If I decide to check if only port 2220 is open on 176.9.9.172, it tells me that it is. However, when I run option 0 to check ALL the ports up to 10000, it only registers that port 22 and port 80 are open. It's multi-threaded and runs up to 4 threads at a time. It waits for the 4 threads to complete and then deletes them and resets the vector of threads to reduce memory issues. I'm not sure what's causing the problem.

UPDATE - I added a section of code after myNetworkSocket = socket(AF_INET, SOCK_STREAM, 0); in the TestPortConnection() function, and as I ran it, I found that the socket creation failed after I scanned ports 1 - 1023. I realized that I forgot to close the ports if they failed to connect in some situations. I inserted the code to close them, and it works now!

I am running the BasicPublisher/BasicSubscriber pair from https://github.com/real-logic/aeron binding them to the same multicast group+port. When they run on the same host they connect, but when they run on separate hosts (same switch+subnet+vlan) the publisher reports "Offer failed because publisher is not connected to subscriber”. Here are my configurations:

AERON PAIR:

I have just started working with TCP (and all associated libraries) due to the need to implement communication between two processes over an internet connection. My code works but it is very slow compared to what I (perhaps due to lack of experience) would expect given the network latency and bandwidth. Also, I'm sure there are many other things wrong with the code, which is using the UNIX socket API. I would prefer not to use big libraries (such as Boost) for my project unless there is a very good reason.

I include a minimal working example. It is rather long despite my best efforts to shorten it. However, I think most of the problems should be in the first file (tcp_helpers.h) which is only used by the client and server main programs in a fairly obvious way. The functions there are not fully optimized but I find it hard to believe that is the problem, rather likely are some fundamental flaws in the logic.

I also want to ask some questions relevant to the problem:

1. For network performance, should I worry about using IPv4 vs IPv6? Could it be that my network dislikes the use of IPv4 somehow and penalized performance?
2. Since the Socket API emulates a stream, I would think it does not matter if you call send() multiple times on smaller chunks of data or once on a big chunk. But perhaps it does matter and doing it with smaller chunks (I call send for my custom protocol header and the data separately each time) leads to issues?
3. Suppose that two parties communicate over a network doing work on the received data before sending their next message (as is done in my example). If the two processes take x amount of time on localhost to finish, they should never take longer than (2*x + (network overhead)) on the real network, right? If x is small, making the computations (i.e. work before sending next message) go faster will not help, right?
4. My example program takes about 4ms when running on localhost and >0.7 seconds when running on the local (university) network I'm using. The local network has ping times (measured with ping) of ( min/avg/max/mdev [ms] = 4.36 / 97.6 / 405. / 86.3 ) and a bandwidth (measured with iperf) of ~70Mbit/s. When runnin the example program on the network I get (measured with wireshark filtering on the port in question) 190 packets with an average throughput of 172kB/s and average packet size ~726 Bytes. Is this realistic? To me it seems like my program should be much faster given these network parameters, despite the fairly high ping time.
5. Looking at the actual network traffic generated by the example program, I started thinking about all the "features" of TCP that are done under the hood. I read somewhere that many programs use several sockets at the same time "to gain speed". Could this help here, for example using two sockets, each for just one-way communication? In particular, maybe somehow reducing the number of ack packets could help performance?
6. The way I'm writing messages/headers as structs has (at least) two big problems that I already know. First, I do not enforce network byte order. If one communicating party uses big-endian and the other little-endian, this program will not work. Furthermore, due to struct padding (see catb.org/esr/structure-packing/), the sizes of the structs may vary between implementations or compilers, which would also break my program. I could add something like (for gcc) __attribute__((__packed__)) to the structs but that would make it very compiler specific and perhaps even lead to inefficiency. Are there standard ways of dealing with this issue (I've seen something about aligning manually)? (Maybe I'm looking for the wrong keywords.)