jetbrains-research / cfpq-on-gpgpu Goto Github PK

Implement tensor product based cfpq algorithm by using Cutlass library.

• Implement tensor (kronecker) product by using Cutlass library.
• Implement cfpq algorithm by using tensor product.
• Evaluate and compare with other implementations.

Publish results at the GRADES-NDA conference

• Implementation
  • GPGPU
    • 4 russin GPGPU (#1)
    • naive GPGPU (#5)
  • CPU
    • m4ri
    • Python sparse
• Evaluation
  • Graphs
  • Linear input (optional)
• Paper (TeX sources)
  • Abstract, march 11
  • Full text, march 18

I think that data set and algorithms implementations should be placed into different repositories.
One for the data set. One for each algorithm: the set of matrix-based algorithms, (G)LL-LR-based algorithms. We should provide the ability to integrate new implementation into the benchmark. I think that it can be done by using git submodules. each implementation can be included as a submodule.

• Is it possible to create a live table with evaluation results?
• Is it possible to use a CI server for algorithms comparison?

Implement a method of four Russian on GPU with appropriate wrappers for kernel invocation (with and without pre-allocation of the table and matrices )

• Add README-s. How to contribute: new data for evaluation, new implementations (on existing platforms, on new platforms)
  • root
  • data sets
  • implementations
• What about CI, docker, etc?
• Publish

• Graphs generated by Rustam I think, that all content should be moved to this repo. Should I copy all data for evaluation to this repo?
• Cases from https://arxiv.org/pdf/1812.03975.pdf (Rustam)
• Linear input form data\bio folder

RDFs in our dataset are not big enough. It is necessary to find new RDFs with a bigger size.

Add data and query form "Demand-driven Alias Analysis for C" (Xin Zheng and Radu Rugina).

We use data from this article in our work. Ilya Kirillov can help to extract graphs from C code.

A number of serialized graphs: https://github.com/YaccConstructor/Meerkat/tree/master/core/src/test/resources/static_analysis

Should we store graphs? I think that for synthetic graphs (worst case, sparse-to-full) we should create generators. Also, I think that for real-world data we should provide converters to our format, instead of converted graphs storing.

In current implementations, we suppose that all data fit in GPU memory. How to handle really huge graphs? Try to implement a multi-GPU solution for graphs which cannot be fully stored in RAM. It should be possible to utilize classical solutions for distributed huge matrices multiplication.

Make M4RI GPU-friendly.

• Create separated BMM procedures
• Create procedures for computations over F2
• Evaluate them, compare with original procedures from M4RI
• Open pull request

Hi

I have tried to run the experiments as described in this README file:
README.md (branch 'documentation')
I have an Ubuntu 18.04.2 machine.
Firstly I downloaded the files with git lfs, ran build_tests.py and then ran the following command in the CFPQ-on-GPGPU root folder (my docker image is called cfpq):

$ sudo docker run -v . cfpq

Then I got the following output:

docker: Error response from daemon: OCI runtime create failed: container_linux.go:344: starting container process caused "process_linux.go:424: container init caused \"apply apparmor profile: apparmor failed to apply profile: open /proc/self/attr/exec: no such file or directory\"": unknown. ERRO[0179] error waiting for container: context canceled.

I do not know how to use docker very well, but I believe it is not the problem, since it created the cfpq image succesfully (it has more than 5Gb of size).

I do not have an NVIDA graphics card. I have an Intel UHD 620, which supports Open CL, but I am not sure if it is compatible with CUDA.

So my questions are:
1 - Am I doing something wrong in the tests execution process?
2 - Is it possible to run the tests without an NVIDA graphics card, but with one that supports Open CL?

Current GPU-based implementations utilize dense matrices, but real graphs are sparse.
We should try to utilize sparse boolen matrices for CFPQ.

• Try to find works/papers/projects on sparse boolean matrices multiplication.
• Try to adopt classical libraries for sparse matrices for boolean matrices processing
  • NSparse: paper and implementation
  • Try to check CUTLASS
  • Regularizing Irregularity: Bitmap-based and Portable Sparse Matrix Multiplication for Graph Data on GPUs
  • An Efficient Storage Format for Large Sparse Matrices based on Quadtree. Investigate Quadtree-based BMM representation and multiplication.
• Implement CFPQ by using sparse atrices
• Evaluate
• Publish (GRADES-NDA)

Parsing input files, mainloop and result output. I.e. generic wrapping stuff, doing all the work except actual matrix operations.

Implement matrix based cfpq algorithm by using Cutlass library.

• Boolean matrices version. Use as small representation of bool value as possible.
• Set of nonterminal matrices version.
• Evaluate and compare.

There is a GPraphBLAS implementation which supports MPI. We can use it to implement distributed CFPQ.

• Pair of matrices per node for independent pairs if exists.
• Distributed multiplication of two matrices.
• Evaluate implementations on the data set and compare with other implementations.
• Evaluate scalability on MPI cluster.

• Implement cfpq by using nsparse library. Use set-of-nonterminal representation of matrices cells. So, first of all, you should to modify multiplication operation in nsparse library.
• Evaluate and compare with other implementations.

Implement utils functions such as memory transfer, management and timer for GPU