Add content to game developer roadmap (#8415 )
* Improve coroutine content with resources * Improve flow-control content with resources * Improve congestion control content with resources * Improve reliable transmission content with resources * Improve error detection content with resources * Improve channel content with resources * Improve max-segment-size content with resources * Improve max-segment-size content with resourcespull/8419/head
parent
e0589284ef
commit
a2018556cd
7 changed files with 109 additions and 1 deletions
@ -0,0 +1,17 @@ |
||||
# Channel |
||||
|
||||
A **channel** is a synchronization primitive used to communicate between concurrent tasks or |
||||
threads, particularly in asynchronous programming. In server-side game development, channels |
||||
are frequently used to manage data flow between different components, such as game logic, |
||||
network communication, and I/O operations. `Channels` provide a thread-safe way to pass messages |
||||
or data between coroutines or threads without the need for complex locks, reducing the chances |
||||
of race conditions. This makes them ideal for handling tasks like event propagation, message |
||||
passing, or coordinating actions in multiplayer game servers. `Channels` often work in |
||||
conjunction with futures and promises to efficiently manage concurrency and improve overall |
||||
game performance. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@documentation@Go Channel Documentation](https://golang.org/doc/effective_go.html#channels) |
||||
- [@documentation@Rust Channels for Concurrency](https://doc.rust-lang.org/book/ch16-02-message-passing.html) |
||||
- [@article@Comprehensive Guide to Channel](https://elixir-lang.org/getting-started/processes.html#using-processes-and-messages) |
@ -0,0 +1,15 @@ |
||||
# Congestion Control |
||||
|
||||
**Congestion control** is a fundamental mechanism in `TCP` that prevents excessive data |
||||
transmission from overwhelming the network, ensuring stable and efficient communication. |
||||
In server-side game development, congestion control helps maintain smooth gameplay by |
||||
dynamically adjusting the data flow based on network conditions. `TCP` employs various |
||||
congestion control algorithms, such as `Reno`, `CUBIC`, and `BBR`, to detect congestion and |
||||
reduce packet loss. These algorithms regulate the senders transmission rate using strategies |
||||
like slow start, congestion avoidance, and fast recovery. Proper tuning of congestion control |
||||
mechanisms is critical for minimizing lag, preventing packet drops, and optimizing multiplayer |
||||
game performance, especially in high-traffic scenarios. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@article@Congestion Control in Linux TCP](https://www.usenix.org/conference/2002-usenix-annual-technical-conference/congestion-control-linux-tcp) |
@ -0,0 +1,13 @@ |
||||
# Coroutine |
||||
|
||||
**Coroutines** are lightweight, cooperative multitasking constructs that enable efficient asynchronous programming in server-side game |
||||
development. Unlike traditional threads, coroutines allow functions to be paused and resumed without blocking the entire execution |
||||
thread, making them ideal for handling game logic, networking, and AI behavior with minimal overhead. They work seamlessly with |
||||
future & promise mechanisms, simplifying concurrency management by avoiding callback hell and reducing synchronization complexity. |
||||
Coroutines are widely supported in modern languages like C++ (via `std::coroutine`), Python (`asyncio`), and Kotlin, offering game |
||||
developers an efficient way to write non-blocking code while maintaining readability and performance. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@documentation@C++ Coroutines (cppreference)](https://en.cppreference.com/w/cpp/language/coroutines) |
||||
- [@documentation@Python Coroutines and Tasks](https://docs.python.org/3/library/asyncio-task.html) |
@ -0,0 +1,14 @@ |
||||
# Error Detection |
||||
|
||||
**Error detection** ensures data integrity in `TCP-based` communication, preventing corrupted |
||||
or altered packets from disrupting server-side game interactions. `TCP` uses checksums to verify |
||||
data integrity, detecting bit errors during transmission. If an error is found, the corrupted |
||||
packet is discarded, and retransmission is requested via acknowledgments (ACKs). Additional |
||||
mechanisms such as cyclic redundancy check (CRC) and parity checks may be used in lower |
||||
network layers to enhance reliability. Effective error detection minimizes data corruption |
||||
in multiplayer games, ensuring smooth gameplay and synchronization across players. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@article@Error Detection Code – Checksum](https://www.geeksforgeeks.org/error-detection-code-checksum/) |
||||
- [@article@Error Control in TCP](https://www.cisco.com/c/en/us/support/docs/ip/tcp/13733-40.html) |
@ -0,0 +1,17 @@ |
||||
# Flow Control |
||||
|
||||
**Flow control** is a crucial mechanism in `TCP` that regulates data transmission between a sender |
||||
and a receiver to prevent network congestion and packet loss. In server-side game development, |
||||
effective flow control ensures smooth data transfer, reducing latency and improving real-time |
||||
responsiveness for multiplayer games. `TCP` uses techniques like sliding window protocols, where |
||||
the receiver dictates how much data it can handle at a time, preventing buffer overflows. |
||||
Additionally, congestion control algorithms like `TCP Reno` and `CUBIC` help dynamically adjust |
||||
transmission rates based on network conditions. Proper flow control tuning is essential for |
||||
maintaining stable connections, minimizing lag, and optimizing server performance in |
||||
high-traffic gaming environments. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@article@How Flow Control is Achieved in TCP?](https://datatracker.ietf.org/doc/html/rfc5681) |
||||
- [@article@Flow Control vs. Congestion Control in TCP](https://www.baeldung.com/cs/tcp-flow-control-vs-congestion-control) |
||||
- [@article@TCP Flow Control](https://www.sanfoundry.com/computer-network-tcp-flow-control/) |
@ -1 +1,18 @@ |
||||
# Max Segment Size |
||||
# Max Segment Size (MSS) |
||||
|
||||
**Max Segment Size (MSS)** is a crucial concept in `TCP` networking, representing the largest |
||||
amount of data that can be sent in a single `TCP` segment, excluding the `TCP` header. `MSS` is |
||||
vital for optimizing performance in server-side game development, as it helps to avoid |
||||
fragmentation and ensures that data is transmitted efficiently over the network. By adjusting |
||||
the `MSS`, game servers can minimize packet fragmentation, which can lead to increased latency |
||||
and reduced throughput. Typically, `MSS` is determined during the `TCP` handshake based on the |
||||
maximum transmission unit (MTU) of the network, and it can be configured to suit the needs of |
||||
specific applications or networks. Optimizing `MSS` can improve the overall reliability and |
||||
performance of data transfers, especially in multiplayer games where real-time communication |
||||
and high throughput are essential. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@article@RFC 879 - Maximum Segment Size](https://tools.ietf.org/html/rfc879) |
||||
- [@article@What is MSS (maximum segment size)?](https://www.cloudflare.com/learning/network-layer/what-is-mss/) |
||||
- [@documentation@TCP Maximum Segment Size tuning](https://www.ibm.com/docs/en/aix/7.2?topic=tuning-tcp-maximum-segment-size) |
@ -0,0 +1,15 @@ |
||||
# Reliable Transmission |
||||
|
||||
**Reliable transmission** ensures that data sent over a network reaches its destination |
||||
accurately and in the correct order, a critical requirement for server-side game development. |
||||
`TCP` achieves this through mechanisms like acknowledgments (ACKs), sequence numbers, and |
||||
retransmission strategies. When a packet is lost or corrupted, `TCP` retransmits it using |
||||
algorithms such as automatic repeat request (ARQ) and fast retransmit. Additionally, flow |
||||
control and congestion control work together to prevent data loss due to network congestion. |
||||
Reliable transmission is essential for maintaining synchronization in multiplayer games, |
||||
preventing desynchronization issues, and ensuring a smooth gaming experience. |
||||
|
||||
Visit the following resources to learn more: |
||||
|
||||
- [@article@Reliable Transmission](https://book.systemsapproach.org/direct/reliable.html) |
||||
- [@article@TCP Reliable Transmission (IETF RFC 793)](https://datatracker.ietf.org/doc/html/rfc793) |
Loading…
Reference in new issue