Core Refactor: Worker, MP asyncio

[thehapax]

Discussion on Core Refactor, originated on Telegram

Goal is to make the Worker Infrastructure for Dexbot use multiprocessing and asyncio to speed up computations on CPU and I/O.

Legacy code not used anymore

• State machine in Base Strategy can be removed

Open issues for discussion:

• Events in Base Strategy : This callback-based event handling needs heavy refactor, especially if the core (worker infrastructure) will use asyncio/multiprocessing/whatever
• GUI interaction with Worker.
• Worker Infrastructure : refactor to use multiprocessing
• Storage, Logging
• Strategies
• Price and Order Engines

Interaction Diagraming and UML to be added to the TDD: Technical Design Doc

[thehapax]

@bitfag please elaborate on

This callback-based event handling needs heavy refactor, especially if the core (worker infrastructure) will use asyncio/multiprocessing/whatever

[bitphage]

Thoughts on architecture:

• Split core and frontends. Core can be a standalone cli app exposing API, and different frontends (CLI / GUI / Web) can use this API to interact with core
• Use asyncio eventloop as core basement. All core parts are logically split into asyncio.Tasks:
  • API: frontends interaction
  • Plugin infrastructure: run plugins (each plugin is separate Task, see 500 plugin infrastructure #502 )
  • WorkerInfrastructure Task: it manages bitshares subscriptions and handling events. On each incoming event, it adds this event into each worker queue object. So, workers will process all events in parallel, and no blocking will occur between incoming events, as WorkerInfrastructure doesn't need to wait while all workers will finish the processing of current event to take a next one.
  • Each worker is running as separate Task, using a coroutine run_forever() with infinity loop inside. This coroutine checks worker's queue and process events from it

What has to be figured out: currently the core (WorkerInfrastructure) is based on bitshares.Notify. On startup it subscribes to markets, blocks, accounts. bitshares.Notify uses websocket-client callbacks. So basically when something happening on the bitshares, Notify gets event, then it's propagated to all workers. Async variant of bitshares.Notify has to use websockets library which doesn't have callbacks, it uses coroutines. Because it is not yet implemented, I cannot say how exactly we will use it. Probably we will have some for loop which passes events to the workers (by adding them into queues of the workers as described above)

For multiprocessing, I don't know what are you planning exactly. If you're going to run each worker as separate process, you cannot use callbacks at all. Each worker will have to use own BitShares instance and manage subscriptions on it's own. It's just like running N dexbot instances with single worker in each.

I don't clearly see how exactly we can benefit from multiprocessing. What is it may be good for, is to push some long-running computations into separate processes, as laid out in this example https://docs.python.org/3/library/asyncio-eventloop.html#executing-code-in-thread-or-process-pools

[thehapax]

• Split core and frontends. Core can be a standalone cli app exposing API, and different frontends (CLI / GUI / Web) can use this API to interact with core

I agree on this aspect to split core and front ends

re: bitshares.Notify: lets wait for xeroc if he is implementing this and see what happens

As for multiprocessing, I don't think this is best way. Perhaps multithreading.

[thehapax]

State machine has been removed and merged into devel

[thehapax]

Something to consider for design.

• Future strategies may be based in heavy computation AI/ML (as per conversation with Gabriel).
  We should think about how to make these separate processes connect with dexbot strategy framework.

[bitphage]

A strategy can use ProcessPoolExecutor to run heavy computations not blocking the main process. https://docs.python.org/3/library/asyncio-eventloop.html#executing-code-in-thread-or-process-pools

[thehapax]

Ok sounds good. I'll take a look into it

[MarkoPaasila]

I like the queue idea for using the pybitshares instance. That will allow for maximizing throughput of one bitshares-instance. Would a step forward be to have pybitshares operate from a queue (no async yet), and separate each worker into a thread of it's own? That way workers would have a break while waiting for data, and give other workers the opportunity to add their questions to the queue. Then the earlier workers would resume. I would imagine that could speed up stuff by a factor of two, and async would yield another x10 later on.

How hard would it be to make an API to separate gui from core? There's not terribly much communication going on there I guess. What kind of API would be best for enabling different frontends? A web interface over LAN or ssh would be a nice possibility, and a Telegram control too :-).