ipmap | Fast IP table structure

I've played around a bit starting from your rules and got to this:

With all concurrency frameworks there is always a trade-off between the amount of concurrency that is deployed vs. the complexity involved for each unit of concurrency. Akka is no exception.

In your non-akka approach you have a relatively simple sequence of steps for each line:

1. read a line from the file
2. split the line by '-'
3. submit the ip address into a hashmap & increment the count

By comparison, your akka approach is much more complicated for each line:

1. create an Actor
2. create a LogLineMessage message
3. send the message to the actor
4. split the line by '-'
5. create a LineProcessingResult message
6. send the message back to the coordinating actor
7. submit the ip address into a hashmap & increment the count

If we naively assumed each of the above steps took the same amount of time then you would need 2 threads with akka just to run at the same speed as 1 thread without akka.

Make Each Concurrency Unit Do More Work

Instead of having 1 Actor per 1 line, have each actor process N lines into its own sub-hashmap (e.g. each Actor processes 1000 lines):

I am not sure whatever you are trying to do will work, as combining complex classes from complex hierarchies is in no way guaranteed to work.

In this case, although you don't mention it, you are trying to combine db.Model which I take to be the class used by flask_sqlalchemy with sqlalchmey.table - both classes are "full of magic tricks" and this include that each have a different metaclass.

Python won't instantiate classes that inherit from independent metaclasses - instead you will get the "metaclass conflict" error you just saw. But, if metaclasses are written in a way that it is possible that they are collaborative, it is a matter of combining both metaclasses, which can be done in a single line of code.

Looking at the source code for the metaclass of sqlalchemy.Table, which is VisitableType in this file, we see that it indeed makes use of super where it matters. That should be all it takes for the class to be collaborative - although one can't be sure that there won't be conflicts in attribute names or other custom mechanisms implemented by the metaclasses.

Anyway, that checked, all that is needed for your code to build and you be able to inherit from both classes is to create the combined metaclass: