Code not working

[ns-krishnakodali]

Hey, I am new to Gleam and experimenting with the actors. For some weird reason the block inside list.each inside worker's handle_message is not being computed. Especially when computing sum_of_squares, the subsequent lines are not being reached.

If someone could take a look at this, that would be really helpful. Thanks in advance :)

Following is my code for ref:

Supervisor

import gleam/erlang/process
import gleam/float
import gleam/int
import gleam/io
import gleam/list

import collector.{type CollectorSubject}
import sum_worker.{ComputeSum}

const tasks_per_worker = 1024

pub fn bootstrap(n: Int, k: Int) -> Nil {
  let collector_subj: CollectorSubject = collector.get_subject()

  spawn_workers(collector_subj, n, k)

  let ps_list =
    process.call(collector_subj, waiting: 10_000, sending: collector.Get)
  case list.length(ps_list) {
    0 -> io.println("No sequences present")
    _ ->
      list.each(list.reverse(ps_list), fn(idx) {
        io.println(int.to_string(idx))
      })
  }
}

pub fn spawn_workers(collector_subj: CollectorSubject, n: Int, k: Int) -> Nil {
  let total_workers: Int =
    float.truncate(float.ceiling(
      int.to_float(n) /. int.to_float(tasks_per_worker),
    ))

  list.range(1, total_workers)
  |> list.each(fn(idx) {
    let worker_subj = sum_worker.get_subject(collector_subj)
    let n1: Int = 1 + { idx - 1 } * tasks_per_worker
    let n2: Int = int.min(n, idx * tasks_per_worker)

    let tasks_list = list.range(n1, n2)

    process.send(worker_subj, ComputeSum(tasks_list, n1, k))
  })
}

Worker

import gleam/erlang/process.{type Subject}
import gleam/float
import gleam/int
import gleam/list
import gleam/otp/actor

import collector.{type CollectorSubject}

pub fn get_subject(collector_subj: CollectorSubject) -> Subject(WorkerMessage) {
  let assert Ok(actor) =
    actor.new(collector_subj)
    |> actor.on_message(handle_message)
    |> actor.start

  actor.data
}

fn handle_message(
  state: CollectorSubject,
  message: WorkerMessage,
) -> actor.Next(CollectorSubject, WorkerMessage) {
  case message {
    ComputeSum(tasks_list, n, k) -> {
      list.each(tasks_list, fn(n1) {
        let squares_sum: Int =
          sum_of_squares(n1 + k - 1) - sum_of_squares(n1 - 1)
        let sqrt_value: Float = case int.square_root(squares_sum) {
          Ok(value) -> value
          Error(_) -> -1.0
        }
        case float.floor(sqrt_value) == sqrt_value {
          True -> {
            process.send(state, collector.Add(n + 1))
          }
          False -> Nil
        }
      })
      actor.continue(state)
    }
    Shutdown -> {
      actor.stop()
    }
  }
}

pub fn sum_of_squares(n: Int) -> Int {
  { n * { n + 1 } * { 2 * n + 1 } / 6 }
}

pub type WorkerMessage {
  ComputeSum(List(Int), Int, Int)
  Shutdown
}

[lpil]

Hello! Welcome to Gleam!

I'm afraid I don't know what the problem is with your code (you may have more luck getting help in the discord chat server's "questions" channel).

It's rather challenging to know what the problem is because this is quite a lot of code, yet some of the code is missing, and you've not shared the output including any errors that occur. The best way to get help is to produce the smallest amount of code that fully reproduces the behaviour you're confused with, and to share the unexpected output. That way people can understand and debug without having to do lots of extra work, so they'll be more able to help you. For trickier problems if you can share the reproduction as a git repo that folks can download and run that is especially helpful, as otherwise they'll have to try and manually recreate your project to debug it.

Misc code feedback

I wanted to point out that your "supervisor" code isn't a supervisor! A supervisor is a specific thing in OTP, it's a special process that starts other children, monitors them, traps their exits and restarts the children according to a specified strategy when they exit. This is almost always done using Erlang's supervisor module, or one of the Gleam or Elixir modules which wrap that module.

You may also want to rename your sum_worker.get_subject function to sum_worker.start and have it return the StartResult type that actor.start returns. This is the convention for a function that starts an actor, and with the name get_subject it sounds like it does not start an actor, but instead it gets a subject from some storage somewhere.

[ns-krishnakodali]

Thanks for pointing some things out @lpil. Regarding the supervisor, earlier I was using a static_supervisor but later changed the logic, although the filename remained the same. The updated code is in the following repo:
https://github.com/ns-krishnakodali/distributed-operating-systems/tree/main/sum_of_squares

The main issue is inside ComputeSum. After computing the squares_sum, the program is not executing beyond this line:

let sqrt_value: Float = case int.square_root(squares_sum) {
    Ok(value) -> value
    Error(_) -> -1.0
}

I have been stuck with this for a while. Any help would be much appreciated.

[ns-krishnakodali]

Found the main issue which was due to improper handling of processes. When spawning multiple actors, the program was not waiting for all of them to finish, it spawned them and exited immediately. I added a mechanism to wait until all actors complete their work concurrently. You can check out my solution here:
https://github.com/ns-krishnakodali/distributed-operating-systems/tree/main/sum_of_squares