Currently, it's easy to leverage GPU acceleration for computations in Python. Can this be achieved using JSL alone?
Thanks Experts!
64bit win10
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.
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":white_heavy_check_mark:</img> Computation complete, results saved to {csv_path}")
pythonHow can to JSL？
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.
