Can JMP Software's JSL operations use GPU acceleration?

[#1]

Currently, it's easy to leverage GPU acceleration for computations in Python. Can this be achieved using JSL alone?

Thanks Experts!

64bit win10

[#2]

Here is a recent reply to a discussion item from MZWald of the JMP Staff about multiple core usage and GPU's

Some platforms in JMP only use a single thread so having many threads wouldn't add much value, but having that single thread running at a faster frequency would add value.  Some platforms in JMP do take advantage of multiple threads so having more threads/cores does help.

With the Torch add-in in JMP Pro 18, now for the first time a GPU will be utilized for image classification and deep learning which does those tasks orders of magnitude faster than a CPU. 

[#3]

[#4]

import pyopencl as cl
import pyopencl.array as cl_array
import numpy as np
import csv
import os
import time

# Select OpenCL platform and GPU device
platform = cl.get_platforms()[0]  # Select the first platform (e.g., AMD)
device = platform.get_devices()[0]  # Select the first GPU device (e.g., gfx804)
context = cl.Context([device])
queue = cl.CommandQueue(context)

# Define the GPU computation kernel (squares array elements)
kernel_code = """
__kernel void square(__global float *arr) {
    int gid = get_global_id(0);
    arr[gid] = arr[gid] * arr[gid];
}
"""
program = cl.Program(context, kernel_code).build()

# Create the CSV file path
csv_path = r"C:\0\results.csv"  # Changed to a more common name

# Ensure the directory exists
os.makedirs(os.path.dirname(csv_path), exist_ok=True)

# Run 10,000 computation tasks
n = 10**6  # 1 million data points per computation
num_iterations = 10_000

# Pre-allocate arrays
host_array = np.empty(n, dtype=np.float32)
gpu_array = cl_array.empty(queue, host_array.shape, dtype=host_array.dtype)

# Store results
results = []

# Random number generator
rng = np.random.default_rng()

# Start timing
start_time = time.time()

for i in range(num_iterations):
    # Generate random data and fill host_array
    host_array[:] = rng.random(n, dtype=np.float32)

    # Upload data to GPU
    cl.enqueue_copy(queue, gpu_array.data, host_array)

    # Compute on the GPU
    program.square(queue, gpu_array.shape, None, gpu_array.data)

    # Retrieve data from GPU
    cl.enqueue_copy(queue, host_array, gpu_array.data)

    # Record the first 5 results
    results.append([i + 1] + host_array[:5].tolist())

    # Progress display
    if (i + 1) % 100 == 0:
        print(f"Completed {i + 1}/{num_iterations} iterations...")

# Total time statistics
end_time = time.time()
total_time = end_time - start_time
print(f"Total time: {total_time:.2f} seconds")
print(f"Average time per iteration: {total_time / num_iterations:.6f} seconds")

# Write results to CSV in a single operation
with open(csv_path, "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["Iteration", "Result 1", "Result 2", "Result 3", "Result 4", "Result 5"])  # CSV header
    writer.writerows(results)

print(f" Computation complete, results saved to {csv_path}")

python
How can to JSL？

[#5]

At present, you can't.  

Using Python and either PyCUDA or pyOpenCL is about the only way to access GPUs from scripting in JMP.  As shown in one of my previous posts, you can create user defined JSL functions that implement functionality in Python using the Python Execute().  This way you can write the GPU Code in Python, yet still present a JSL interface for the rest of your scripting.