Multi-Threaded Matrix Calculator

[rten19]

Project Abstract This document proposes a matrix calculator web application that supports a wide variety of matrices and matrix operations (multiplication, Gaussian elimination, inversion, decomposition, etc.). The application will employ machine learning and multi-threaded calculations, allowing users to do matrix operations quickly. In addition, it will also provide a user-friendly GUI that visualizes matrix operations step-by-step with explanations and creates graph representations of matrices. There will also be a “benchmarking” feature that will compare the performances of various algorithms used in operations.

Conceptual Design The program will run mainly on Java and work on any operating system. NumPy is needed for machine learning in various decomposition techniques, and HTML, CSS and/or Javascript will be used for the GUI on the web application.

Proof of Concept GitHub repository: https://github.com/rten19/multi-threaded-matrix-calc

Steps to compile and run:

1. Make sure Java is installed on your computer.
2. Click on “Code” (in green) and click “Download ZIP.”
3. Extract the .zip folder into a destination of your choice.
4. Open Git Bash and cd into the destination.
5. Run the command “javac Matrix.java” to compile the code.
6. Run “java Matrix” to run the program.

Background Other web applications provide the ability to perform basic matrix operations, and some show some visualizations of matrix operations. This one will provide a more expansive set of functionalities and more complex operations, from visual benchmarks comparing algorithms to graph representations to operations powered by machine learning and multiple threads.

Required Resources For hardware resources, any machine (laptop/desktop) will be able to use the web application as long as it can run Java.

For software resources, Java is required as well as an IDE to support coding in Java (e.g., Intellij). NumPy will be needed for machine learning used in some matrix decomposition algorithms. HTML, CSS, and/or Javascript is needed for the GUI.

Some knowledge on AI/machine learning is needed, as well as knowledge on web development.

Presentation:

[jayhaych02]

Feedback on Project Proposal: Multi-Threaded Matrix Calculator

Why I Find This Project Interesting: I think this project stands out because matrix multiplication is foundational to many computational tasks, especially in fields like machine learning, graphics rendering, and scientific computing. The use of multi-threading to speed up matrix operations is a clever approach, as matrix multiplication can be broken down into smaller independent tasks, making it ideal for parallelization. I also appreciate the project’s potential to demonstrate efficient use of system resources, something that is critical when dealing with large matrices or real-time applications.

How I Can Contribute: I am particularly interested in exploring the performance aspect of this project because computational speed is a key factor in many of my own projects as well. One potential area of expansion that I'd like to propose is investigating whether Java can be used for GPU programming. Although GPU programming is predominantly done using C++ (with CUDA for NVIDIA GPUs), there may be opportunities to explore Java bindings or libraries such as JCUDA, which allows Java to interface with CUDA. This could open the door to even faster matrix computations by leveraging the power of parallelism on the GPU.

Suggestions for Improvement: Consider GPU Offloading: While the project focuses on multi-threading, an exciting extension could be looking into GPU offloading. While Java isn’t the typical language for GPU programming, frameworks like JCUDA or using JNI (Java Native Interface) to call CUDA functions from Java could provide significant speedups. Investigate Matrix Optimization Algorithms: Another area of potential exploration could be matrix multiplication optimization techniques such as Strassen's algorithm or exploring block matrix multiplication, which is particularly useful for larger matrices.

I believe combining the CPU multi-threading approach with the possibility of offloading intensive tasks to the GPU could make this project even more powerful and provide real-world performance gains, particularly for high-performance computing tasks.

[CBerg333]

I'm very interested in this project as a way to practice implementing hardware acceleration in programs. Since I just got a GPU, I've been looking to use it as much as possible in my daily programming, and I find that it could be used a lot more, even in programs that aren't necessarily graphically intensive. Learning how to optimize matrix multiplication is also timely, considering how relevant it is for machine learning and LLMs. I wonder if there's a method to specifically send processes over to tensor cores vs CUDA cores.

I have some experience working with Tensorflow, which really makes neat work of complex matrix calculations and is particularly excellent at optimizing parallelism (it's even optimized to take advantage of multiple GPUs if available). While I've only worked with it in Python, I found Tensorflow Java while doing some research on how I can contribute to this project. We may be able to take advantage of tensor cores where available if this works out, which would make it even faster.

Since I have a pretty powerful GPU as I've said, it would also make testing really convenient. We could run benchmarks to see how fast it runs comparatively when we send it to the CPU, GPU (CUDA) or GPU (tensor cores). I also have Stable Diffusion installed locally, so we might be able to use this program to see how fast it can train custom models.