Jobs *Any* way to access static data safely?

Unity Engine
,
22

Rough roadmap:

  • Define protocol standards, new noticeable change means new major version.

  • Investigate security, prevent tampering and replay attacks at least.

  • Reliability should sit at low-level for low-latency, consider KCP.

  • Remove hardcoded scatter/gather from transmission functions, pass it as a parameter and add context, make functions more agnostic.

  • Implement fibers, use fcontext_t for green concurrency. If Unity’s jobs already implemented similar way, then half of the work already done.

  • Remove any dependency between a game loop, I/O, and worker threads. No shared data, no shared states, no scheduling from hot-path. Everything should work independently of each other it should be stopless flow/conveyor. Make it truly parallel.

  • Avoid allocations on the heap for everything, use scalable concurrent pools with TLS.

  • Try to avoid/minimize interoperability/cross-language implementation overhead across layers and levels.

  • Organize a clear code structure, eliminate spaghetti.

  • Add pipeline-like API for injecting custom functionality into data flow, extend modularity and flexibility.

  • Implement high-level abstractions as modules for stuff that related to synchronization, various game mechanics, and so on.

  • Use Span for contiguous memory access and buffers manipulation at high-level. Don’t know about JIT optimizations in Mono, but the latest version should support fast Span at least.

  • Stop working in the shadow, nobody wants to contribute to the 2-month outdated repository with a single branch. Organize collaborative workflow, commit in real-time.

  • Provide a code of conduct and contribution guides for not in-house open-source developers.

  • Introduce two concepts like scriptable render pipeline, but for networking. One lightweight for mobile platforms/small games and one advanced for desktop/servers.

  • Investigate sockets-related kernel implementations across platforms.

  • Integrate scalable event interfaces, epoll and kqueue for readiness-oriented I/O on Linux/UNIX/POSIX, and IOCP for completion-oriented I/O on Windows.

  • Implement semi-real world testbed using multiple machines and heavy-load/high-parallelism simulations. Synthetic benchmarking for basic measurements during work.

  • Stabilization, fixes, and gap-closing with continuous updates.

  • Maximize performance and optimize resources usage.

14 Likes