Hello,

  My current setup is just two xboxes connected via system link (wired through a router).  Following the Client-Sever model, one xbox is the host while the other is the client. 

  My client writes out it's current thumbstick positions while the router calculates the position/rotation/etc. and sends it back to the client.

  My client write package consists of:
        xbox trigger values (double: 8 bytes)
        xbox thumbstick values (Vector2: 8 bytes)
        Total: 16 bytes

  My server write package consists of:
        CalculatedPosition (Vector3[numClients]: 12 bytes)
        CalculatedRotation (Vector3[numClients]: 12 bytes)
        CalculatedVelocity (Vector3[numClients]: 12 bytes)
        Total: 36 bytes * numClients.

  When I finally get 4 players connected I'm going to be expecting a server input of 64 bytes and an output of 144 bytes per client.

  However, I've already started noticing some lag with just one-two players (up to about 1 second of lag with just two people; I don't understand why). With a system link setup, I was expecting not having to rely on network prediction to create a seamless connection; especially with such low package sizes being passed around.  Are these package sizes adequate or is there a recommended package size people use for network games? Can there be something wrong with my router?  Does anyone recommend some sort of network monitoring program that would point out what's slowing things down?  I was really hoping to get smoother gameplay with a system link setup.  Thanks!

I'm guessing you're using the NetRumble starter kit for this. It only sends out packets every so often and I think this is probably what is causing the lag. You could try sending them out more often. For system link you should be able to do it way more often than XBL.
You can try wireshark to monitor the network packets sent if you want.

Impossible to say for sure without seeing more code, but my telepathic powers suggest that perhaps your client machines are just reading one packet per frame, rather than reading in a while (gamer.IsDataAvailable) loop?

LocoPuyo:  Thanks for the advice. I've been using the Client-Server example for my network endeavors so far.  The NetRumble example seemed too intimidating but it looks it's time to move on to bigger and better things. I'm looking through it now. When you mean "send more packets" are you suggesting just calling ".sendData" multiple times in one frame?

Shawn:  Here's some psuedo code of what I'm doing:

My main network update which occurs in the game update loop.

How I handle client/server input and output:

So, with my limited networking experience, it seems like the clients are receiving the packets sent from the server.  While debugging my project, I can see the server reading client inputs with no problem.  It's just waiting for the client to receive info from the server is what's causing the lag.  When I hook up another client (using my PC: 2 clients and 1 host) things get really choppy.  However I notice Client A updating normally (with minor pangs of lag) while Client B takes about 10 seconds or more to update the position sent from the server.  It gets so bad that I just end up watching what Client B is doing from Client A's screen.  It's as if one client is getting priority over the other in regards to receiving updated positions from the server. Anyway,  please let me know if you have any ideas.  Until then, I'll look over the NetRumble code.

In t he netrumble it doesn't send out packets to every player every frame. it finds out how many max players there can be, which is set to 16, then staggers when it sends packets out every 16 frames.

I'm no expert to how it works, but just a guess is that the framerate may be slower on one and its getting way more packets than it needs every frame and can't handle it. Falling behind and processing packets that are older and older.

Note that "packet" or "message" generally is not the same thing as UDP datagram. The network framework will generally pack multiple messages into a single UDP datagram. You really need to drain the incoming message queue fully each time through your main loop.

LocoPuyo:

I'm no expert to how it works, but just a guess is that the framerate may be slower on one and its getting way more packets than it needs every frame and can't handle it. Falling behind and processing packets that are older and older.

jwatte:

Note that "packet" or "message" generally is not the same thing as UDP datagram. The network framework will generally pack multiple messages into a single UDP datagram. You really need to drain the incoming message queue fully each time through your main loop.

So, when you execute:
    packetWriter.Write(foo);
    LocalNetworkGamer.SendData(packetWriter, SendDataOptions.InOrder);

This creates a "packet" or "message" correct? 

The moment I try to send multiple packets (if I where to put the above code in a for loop) those "packets" are streamed out in a single UDP datagram? 

In my case, I'm noticing problems with the server writing out to clients.  To prevent sending out more packets than the clients to handle, are you talking about using the .Flush() function of a packetWriter in my server main loop?

Also, when I debug my program, should I not be combining different machines for network tests?  I have one PC and 2 xboxes available for my network tests.  When I have the host as the PC and the xboxes as clients, both clients run sluggishly (one being more slow than the other).  However, when I have one xbox set as the host and the other xbox and PC as clients, the PC runs fine while the xbox is still quite sluggish.  Should I stick with only running one type of machine for networking tests?  I really thought there would be no problems with a system link.