opened
archenroot
username_0
So imagine I have multi gpu cluster (GPU node count > 1), I can see few general scenarios (there could be more):

1. Multiple user sessions can share the cuDF, and they execute same operations on load

2. Multiple user sessions can share the cuDF, but they execute different operations

3. Multiple user sessions have different cuDF, they execute same operations (either the functions are generic, or the data model is the same)

4. Multiple user sessions have different cuDF, they execute completely different operations

Q: How is cuxfilter ready for such scenarios? Is there some generic managment construct?
Q: How can I assign just some GPUs in cluster?
Q: Are aggregations (as per demo histogram) persisted in GPU memory and therefore accessible, or they are just returned to user and result is forgotten and again recalculated on next request?

Its really cool, because this can really boost real time aggregations or larger dataset aggregations.
[question] GPU session data management within GPU cluster
issue
created
exactlyallan
username_1
@username_0 Good questions - we've briefly played around with some scenarios. The short answer is because the current cuDF is only single node, the datasets large enough to utilize GPU acceleration were already pushing the limits of single GPU memory size with a single user.

The solution to this is to use the in-development multi-node [dask-cudf](https://github.com/rapidsai/dask-cudf), but we haven't committed to building that yet. Once that is developed, finding methods for advanced user session or resource management would make a lot of sense, as it is pretty basic currently. 

1. There is an ability so use sessions or not, [docs here](https://github.com/rapidsai/cuxfilter/tree/master/client_side#1-load-data), so the effect is similar to sharing a cuDF. Anyone accessing the cuDF would be able to see and alter its state. This means you can do some interesting cross-browser or remote interactions, but its a bit flaky.

2. Something we are looking into is using pointers to GPU memory so dataframes wouldn't have to be duplicated as often - this is assuming you've set the same data dimension for those different operations. 

3 / 4. This would probably be mostly simply done by initializing different cuDFs for each and relying on some sort of resource manager. 

To answer your last question - the aggregations are not stored on GPU memory since their values are so small - but they are stored as part of a cuXfilter object server side.
comment
closed
exactlyallan
username_1
issue