ci: add workflow for cython/cpp linting

.github/workflows/lint_cpp.yml

@@ -0,0 +1,21 @@
+name: CPP Linter
+
+on: pull_request
+
+jobs:
+  cpp-linter:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: cpp-linter/cpp-linter-action@v2
+        id: linter
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          style: llvm
+
+      - name: Fail fast?!
+        if: steps.linter.outputs.checks-failed > 0
+        run: echo "Some files failed the linting checks!"
+        # for actual deployment
+        # run: exit 1

.github/workflows/lint_cython.yml

@@ -0,0 +1,22 @@
+name: Cython Linter
+
+on: [pull_request]
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    permissions:
+      # Give the default GITHUB_TOKEN write permission to commit and push the changed files back to the repository.
+      contents: write
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        ref: ${{ github.head_ref }}
+    - name: Setup Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.11'
+    - name: Install cython-lint
+      run: pip install cython-lint
+    - name: Check code formatting
+      run: cython-lint src/python/parla/cython

.github/workflows/format_with_ruff.yml → .github/workflows/lint_python.yml

@@ -1,4 +1,4 @@
-name: Format Python Code
+name: Python Linter & Format
 
 on: [pull_request]
 

src/c/backend/include/parray.hpp

@@ -7,9 +7,9 @@
 
 #pragma once
 
+#include "atomic_wrapper.hpp"
 #include "containers.hpp"
-#include "include/atomic_wrapper.hpp"
-#include "include/device.hpp"
+#include "device.hpp"
 #include "parray_state.hpp"
 #include <cstdint>
 #include <unordered_map>
@@ -24,8 +24,8 @@
 // scheduling task
 class InnerPArray {
 public:
   uint64_t id;        // unique ID of the PArray
   uint64_t parent_id; // unique ID of the parent PArray
 
   /// Track the number of tasks that are using or are planning to use this
   /// PArray.
@@ -35,7 +35,7 @@
   /// compared to restructuring overheads), but this counter is decreased.
   /// This is used to provide more accurate PArray placement information
   /// to the task mapping step.
   std::vector<CopyableAtomic<size_t>> num_active_tasks;
 
   InnerPArray() = delete;
   InnerPArray(void *, uint64_t, uint64_t, InnerPArray *, PArrayState *,
@@ -43,17 +43,17 @@
 
   /// Get current size (in bytes) of each copy of the PArray
   /// if it is a subarray, return the subarray's size
   const uint64_t get_size() const;
 
   /// Set the size of the PArray
   void set_size(uint64_t new_size);
 
   /// Return True if there is an PArray copy (possibly invalid) on this device
   bool exists_on_device(uint64_t device_id);
 
   /// Return True if there is an PArray copy and its coherence state is valid on
   /// this device
   bool valid_on_device(uint64_t device_id);
 
   /// Add a pointer of the task that will use this PArray to the task list
   void add_task(InnerTask *task);
@@ -65,17 +65,17 @@
   void decr_num_active_tasks(DevID_t global_dev_id);
 
   /// Get the number of counter for the active tasks that use this PArray.
   size_t get_num_active_tasks(DevID_t global_dev_id);
 
   // TODO(hc): I will replace this list with a concurrent map.
   /// Get a reference to a list of tasks who are using this PArray
   TaskList &get_task_list_ref();
 
   /// Return the instance of Python PArray.
   void *get_py_parray();
 
   /// Return the parent id of the current instance.
   uint64_t get_parray_parentid();
 
   /// Return a pointer of the parent PArray.
   InnerPArray *get_parent_parray();

src/c/backend/include/phases.hpp

@@ -167,7 +167,6 @@ class Mapper : virtual public SchedulerPhase {
   void run(SchedulerPhase *next_phase);
   size_t get_count();
 
-
   /// @brief Increase the count of tasks mapped to a device
   /// @param dev_id Device global ID where a task is mapped
   /// @return The number of the tasks mapped to a device

src/c/backend/phases.cpp

@@ -63,8 +63,7 @@ void Mapper::run(SchedulerPhase *next_phase) {
     std::vector<std::shared_ptr<DeviceRequirement>> chosen_devices;
 
     policy_->run_task_mapping(task, *this, &chosen_devices, parray_list,
-        &placement_req_options_vec);
-
+                              &placement_req_options_vec);
 
     if (chosen_devices.empty()) {
       // It means that none of the devices is available for this task.

src/c/backend/policy.cpp

@@ -208,7 +208,8 @@ void LocalityLoadBalancingMappingPolicy::run_task_mapping(
     std::vector<std::shared_ptr<DeviceRequirement>> *chosen_devices,
     const std::vector<std::vector<std::pair<parray::InnerPArray *, AccessMode>>>
         &parray_list,
-    std::vector<std::shared_ptr<PlacementRequirementBase>> *placement_req_options_vec) {
+    std::vector<std::shared_ptr<PlacementRequirementBase>>
+        *placement_req_options_vec) {
   // A set of chosen devices to a task.
   Score_t best_score{-1};
   // If any device was chosen as a candidate device,
@@ -242,8 +243,8 @@ void LocalityLoadBalancingMappingPolicy::run_task_mapping(
       std::shared_ptr<DeviceRequirement> dev_req =
           std::dynamic_pointer_cast<DeviceRequirement>(base_req);
       Score_t score{0};
-      bool is_req_available = calc_score_devplacement(
-          task, dev_req, mapper, &score, parray_list[0]);
+      bool is_req_available = calc_score_devplacement(task, dev_req, mapper,
+                                                      &score, parray_list[0]);
       if (!is_req_available) {
         continue;
       }
@@ -263,9 +264,9 @@ void LocalityLoadBalancingMappingPolicy::run_task_mapping(
       // std::cout << "[Mapper] Task name:" << task->get_name() << ", " <<
       // "Checking arch requirement."
       //           << "\n";
-      bool is_req_available = calc_score_archplacement(
-          task, arch_req, mapper, chosen_dev_req, &chosen_dev_score,
-          parray_list[0]);
+      bool is_req_available =
+          calc_score_archplacement(task, arch_req, mapper, chosen_dev_req,
+                                   &chosen_dev_score, parray_list[0]);
       if (!is_req_available) {
         continue;
       }