For example, you could use the ‘debug’ version when editing in studio which provides additional overhead due to more useful debugging features, and ‘release’ mode when the game is running live without the debugging overhead. Two seperate modules for both ‘debug’ and ‘release’ modes.Feel free to try out tests yourself or improve anything. I will post benchmarks in the future, but at the moment I am too lazy. Throughout the development of the library I have been running tests and benchmarks, but have not saved any. The returned parent process will not terminate until all child processes finish. For example, some of the factory functions such as proto.all implement a parent-child system. There are two additional types of processes: parent and child. In other words, it’s a wrapper over raw threads that allows for process management. In my library, a process is defined as a table containing data to execute and manage some function to be run in a different thread than the invocation. For example, if a function expects a table as an argument then passing any table that does not fit the format of the table it expects will not work and may error. It is important to note this library has some warnings for debugging, but it also assumes you are using it correctly. Comparing the source code shows my library is fundamentally not promise-like, but it can achieve the same problems with better performance. Currently, it is what it originally sought to be as well as an alternative to the promise library implementations. The reduced calling overhead occurred due to the reduction of completely new threads for every call.
Originally, the main goal of this library was to be a light wrapper over the task library that implemented thread pooling for reduced calling overhead. The library mocks the api of the task library, but also offers additional features such as process management: cancellation, chaining, awaiting, status, etc. It prioritizes speed and memory resources by implementing the feature of thread pooling, or reusing the same threads to run many processes. Proto is a concurrent scheduling library that uses the native coroutine library.
0 kommentar(er)
