Add CPU and accelerator options to style transfer demo.

Author: Iainmon

bridge/include/bridge.h

@@ -17,6 +17,8 @@ typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef unsigned long long uint64_t;
 
+void debug_cpu_only_mode(bool_t mode);
+
 typedef struct bridge_tensor_t {
     float* data;
     int* sizes;
@@ -56,9 +58,6 @@ bool_t accelerator_available(void);
 bridge_tensor_t model_forward(bridge_pt_model_t model, bridge_tensor_t input);
 bridge_tensor_t model_forward_style_transfer(bridge_pt_model_t model, bridge_tensor_t input);
 
-uint64_t get_cpu_frame_width(uint64_t width, float32_t scale_factor);
-uint64_t get_cpu_frame_height(uint64_t height, float32_t scale_factor);
-
 bridge_tensor_t resize(bridge_tensor_t input,int height,int width);
 bridge_tensor_t imagenet_normalize(bridge_tensor_t input);
 

bridge/lib/bridge.cpp

@@ -41,12 +41,14 @@ auto best_dtype = get_best_dtype();
 torch::NoGradGuard no_grad;
 torch::AutoGradMode enable_grad(false);
 
-
-
+bool debug_cpu_only = false;
 
 
 
 torch::Device get_best_device() {
+    if (debug_cpu_only) 
+        return torch::Device(torch::kCPU);
+    
     if (torch::hasMPS()) {
         return torch::Device(torch::kMPS);
     } else if (torch::hasCUDA()) {
@@ -56,9 +58,17 @@ torch::Device get_best_device() {
     }
 }
 
+extern "C" void debug_cpu_only_mode(bool_t mode) {
+    debug_cpu_only = mode;
+    if (debug_cpu_only) {
+        best_device = torch::Device(torch::kCPU);
+    } else {
+        best_device = get_best_device();
+    }
+}
+
 extern "C" bool_t accelerator_available() {
-    return false;
-    // return torch::hasMPS() || torch::hasCUDA();
+    return (best_device == torch::Device(torch::kCUDA) || best_device == torch::Device(torch::kMPS));
 }
 
 torch::ScalarType get_best_dtype() {
@@ -251,21 +261,21 @@ extern "C" bridge_tensor_t model_forward_style_transfer(bridge_pt_model_t model,
     return model_forward(model, input, true);
 }
 
-std::tuple<uint64_t, uint64_t> get_cpu_frame_size(uint64_t width, uint64_t height, float32_t scale_factor) {
-    // if (best_device == torch::kMPS || best_device == torch::kCUDA)
-    if (accelerator_available())
-        return std::make_tuple(width, height);
-    uint64_t new_width = static_cast<uint64_t>(width * scale_factor);
-    uint64_t new_height = static_cast<uint64_t>(height * scale_factor);
-    return std::make_tuple(new_width, new_height);
-}
+// std::tuple<uint64_t, uint64_t> get_cpu_frame_size(uint64_t width, uint64_t height, float32_t scale_factor) {
+//     // if (best_device == torch::kMPS || best_device == torch::kCUDA)
+//     if (accelerator_available())
+//         return std::make_tuple(width, height);
+//     uint64_t new_width = static_cast<uint64_t>(width * scale_factor);
+//     uint64_t new_height = static_cast<uint64_t>(height * scale_factor);
+//     return std::make_tuple(new_width, new_height);
+// }
 
-extern "C" uint64_t get_cpu_frame_width(uint64_t width,float32_t scale_factor) {
-    return std::get<0>(get_cpu_frame_size(width, 0, scale_factor));
-}
-extern "C" uint64_t get_cpu_frame_height(uint64_t height,float32_t scale_factor) {
-    return std::get<1>(get_cpu_frame_size(0, height, scale_factor));
-}
+// extern "C" uint64_t get_cpu_frame_width(uint64_t width,float32_t scale_factor) {
+//     return std::get<0>(get_cpu_frame_size(width, 0, scale_factor));
+// }
+// extern "C" uint64_t get_cpu_frame_height(uint64_t height,float32_t scale_factor) {
+//     return std::get<1>(get_cpu_frame_size(0, height, scale_factor));
+// }
 
 
 extern "C" void hello_world(void) {

demos/video/chapel-webcam/lib/smol.h

@@ -32,8 +32,8 @@ void chpl__init_ndarrayRandom(int64_t _ln,
 void chpl__init_smol(int64_t _ln,
                      int32_t _fn);
 chpl_bool acceleratorAvailable(void);
-int64_t getCPUFrameWidth(int64_t width);
-int64_t getCPUFrameHeight(int64_t height);
+int64_t getScaledFrameWidth(int64_t width);
+int64_t getScaledFrameHeight(int64_t height);
 int64_t square(int64_t x);
 void printArray(chpl_external_array * a);
 void globalLoadModel(void);

demos/video/chapel-webcam/main.cpp

@@ -113,8 +113,8 @@ int mirror() {
     const std::string windowName = "Webcam Feed";
     cv::namedWindow(windowName, cv::WINDOW_AUTOSIZE);
 
-    cv::Size frame_size;
-    cv::Size new_frame_size;
+    cv::Size original_frame_size;
+    cv::Size processed_frame_size;
 
     while (true) {
         // Capture a new frame from webcam
@@ -123,23 +123,20 @@ int mirror() {
             std::cerr << "Error: Empty frame captured.\n";
             break;
         }
-        frame_size = frame.size();
-        if (!acceleratorAvailable()) {
-            const auto width = getCPUFrameWidth(frame_size.width);
-            const auto height = getCPUFrameHeight(frame_size.height);
-            new_frame_size = cv::Size(width, height);
-        } else {
-            new_frame_size = frame_size;
-        }
 
-        cv::resize(frame, frame, new_frame_size);
+        original_frame_size = frame.size();
+
+        const auto width = getScaledFrameWidth(original_frame_size.width);
+        const auto height = getScaledFrameHeight(original_frame_size.height);
+        processed_frame_size = cv::Size(width, height);
+        cv::resize(frame, frame, processed_frame_size);
 
-        std::cout << "Frame size: " << frame.size() << std::endl;
-        std::cout << "New frame size: " << new_frame_size << std::endl;
+        // std::cout << "Frame size: " << frame.size() << std::endl;
+        // std::cout << "New frame size: " << processed_frame_size << std::endl;
 
         cv::Mat next_frame = new_frame(frame);
 
-        cv::resize(next_frame, next_frame, frame_size);
+        cv::resize(next_frame, next_frame, original_frame_size);
 
         // Display the captured frame
         cv::imshow(windowName, next_frame);

demos/video/chapel-webcam/smol.chpl

@@ -2,18 +2,39 @@ use Tensor;
 use Layer;
 import Utilities as util;
 
-config const cpuScaleFactor: real(32) = 0.2;
+config const cpuScale: real = 0.2;
+config const accelScale: real = 0.45;
+config const debugCPUOnly: bool = false;
+
+
+const cpuScaleFactor = cpuScale;
+const acceleratorScaleFactor = accelScale;
 
-writeln("CPU Scale Factor: ", cpuScaleFactor);
 
 export proc acceleratorAvailable(): bool do
     return Bridge.acceleratorAvailable();
 
-export proc getCPUFrameWidth(width: int): int do
-    return Bridge.getCPUFrameWidth(width,cpuScaleFactor : real(32));
 
-export proc getCPUFrameHeight(height: int): int do
-    return Bridge.getCPUFrameHeight(height,cpuScaleFactor : real(32));
+export proc getScaledFrameWidth(width: int): int do
+    if acceleratorAvailable() then
+        return (width:real * acceleratorScaleFactor):int;
+    else
+        return (width:real * cpuScaleFactor):int;
+
+export proc getScaledFrameHeight(height: int): int do
+    if acceleratorAvailable() then
+        return (height:real * acceleratorScaleFactor):int;
+    else
+        return (height:real * cpuScaleFactor):int;
+
+
+if debugCPUOnly then
+    writeln("Debugging CPU only!");
+Bridge.debugCpuOnlyMode(debugCPUOnly);
+
+writeln("CPU Scale Factor: ", cpuScaleFactor);
+writeln("Accelerator Scale Factor: ", acceleratorScaleFactor);
+writeln("Accelerator Available: ", acceleratorAvailable());
 
 
 export proc square(x: int): int {

lib/Bridge.chpl

@@ -74,11 +74,7 @@ module Bridge {
     extern "accelerator_available" 
         proc acceleratorAvailable(): bool;
 
-    extern "get_cpu_frame_width" 
-        proc getCPUFrameWidth(width: int(64), scale_factor: real(32)): int(64);
-    extern "get_cpu_frame_height" 
-        proc getCPUFrameHeight(height: int(64), scale_factor: real(32)): int(64);
-
+    extern "debug_cpu_only_mode" proc debugCpuOnlyMode(mode: bool): void;
 
     extern proc convolve2d(
         in input: bridge_tensor_t,