gpu.js | GPU Accelerated JavaScript | GPU library

Background
I've built a little web based application that pops up windows to display your webcam(s). I wanted to add the ability to chroma key your feed and have been successful in getting several different algorithms working. The best algorithm I have found however is very resource intensive for JavaScript; single threaded application.

Question
Is there a way to offload the intensive math operations to the GPU? I've tried getting GPU.js to work but I keep getting all kinds of errors. Here is the functions I would like to have the GPU run:

In an Nvidia developer blog: An Even Easier Introduction to CUDA the writer explains:

To compute on the GPU, I need to allocate memory accessible by the GPU. Unified Memory in CUDA makes this easy by providing a single memory space accessible by all GPUs and CPUs in your system. To allocate data in unified memory, call cudaMallocManaged(), which returns a pointer that you can access from host (CPU) code or device (GPU) code.

I found this both interesting (since it seems potentially convenient) and confusing:

returns a pointer that you can access from host (CPU) code or device (GPU) code.

For this to be true, it seems like cudaMallocManaged() must be syncing 2 buffers across VRAM and RAM. Is this the case? Or is my understanding lacking?

In my work so far with GPU acceleration on top of the WebGL abstraction layer via GPU.js, I learned the distinct performance difference between passing VRAM based buffers (textures in WebGL) from kernel to kernel (keeping the buffer on the GPU, highly performant) and retrieving the buffer value outside of the kernels to access it in RAM through JavaScript (pulling the buffer off the GPU, taking a performance hit since buffers in VRAM on the GPU don't magically move to RAM).

Forgive my highly abstracted understanding / description of the topic, since I know most CUDA / C++ devs have a much more granular understanding of the process.

• So is cudaMallocManaged() creating synchronized buffers in both RAM and VRAM for convenience of the developer?
• If so, wouldn't doing so come with an unnecessary cost in cases where we might never need to touch that buffer with the CPU?
• Does the compiler perhaps just check if we ever reference that buffer from CPU and never create the CPU side of the synced buffer if it's not needed?
• Or do I have it all wrong? Are we not even talking VRAM? How does this work?

How to send data from a dynamic php table inside an anchor tag to another page(description_of_gpu.php) and also how to retrieve that data on the new page.

I am trying to send the variable generated inside the table-data tag to another page, which is in itself retrieved from "MySQL" database. Once I get that data, I will search through my database with the same "NameOfVcard" and display it's discription.

Code inside "gpu_table_page.php"

I'm trying to use GPU.js in Vue. I don't get how I have to import it though. I'm trying this right now:

The following code uses GPU.js, a wrapper for WebGL that makes it easy to run matrix operations with WebGL by simply writing JS functions, I render an image on the canvas, but I want to resize it. I've read about nearest neighbor interpolation but I'm confused on how to implement it. I've already set up the resize kernel, all that's left to be done is interpolation logic.

Notes:

• the current indexes are available within the kernel function as this.thread.x, this.thread.y, and this.thread.z, depending on the dimensions of the matrix your kernel is computing.

• You'll notice the canvas is sized weird. This is a "feature" of GPU.js related to WebGL texture handling (I think they're planning on ironing that out later).

• Edit: Made progress but not quite perfected: http://jsfiddle.net/0dusaytk/59/

I'm probably missing something obvious, but i'm experimenting with gpu.js and getting some strange results. I just want to make sure i'm not doing something obviously stupid (which is likely).

Not sure if this is an issue with what i'm doing, or the way in which calculations are performed when done via gpu.js using WebGL.

I create a new GPU and new kernel:

I have created a mandelbrot set in javascript which uses the gpu but because javascript decimals are not so accurate when I zoom in to much the screen goes pixely. If i were programing it on the cpu it would not be so hard but because I am using gpu.js I cant use strings and therefore no decimal libraries I know.

I only want to increase the accuracy, not make it endless.

Is there any way to create a more precise float with multiple floats (I can not use strings because of the library's limitation) so that I can:

• multiply
• add
• use powers

image of the pixlation

I'm new to the area of geometry generation and manipulation and I'm planning on doing this on an intricate and large scale. I know the basic way of doing this is like it's shown in the answer to this question..

For testing a game art style I thought of, I want to render a 3D world in pixel-art form. So for example, take a scene like this (but rendered with certain coloring / style so as to look good once pixelated):

And make it look something like this:

By playing with different ways of styling the 3D source I think the pixelated output could look nice. Of course to get this effect one just sizes the image down to ~80p and upscales it to 1080p with nearest neighbor resampling. But it's more efficient to render straight to an 80p canvas to begin with and just do the upscaling.

This is not typically how one would use a shader, to resize a bitmap in nearest neighbor format, but the performance on it is better than any other way I've found to make such a conversion in real time.

My buffer for the bitmap is stored in row major, as r1, g1, b1, a1, r2, g2, b2, a2... and I'm using gpu.js which essentially converts this JS func into a shader. My goal is to take one bitmap and return one at larger scale with nearest-neighbor scaling, so each pixel becomes a 2x2 square or 3x3 and so on. Assume inputBuffer is a scaled fraction of size of the output determined by the setOutput method.