Channels in Scilab

// Create a new channel with make(chan val-type).
// Channels are simulated using global variables in Scilab.
global messages;
messages = list();

// Send a value into a channel using the channel <- syntax.
// Here we send "ping" to the messages channel we made above.
function sendMessage()
    global messages;
    messages($+1) = "ping";
endfunction

// Start the sendMessage function in a separate thread
thread_id = threadCreate(sendMessage);

// The <-channel syntax receives a value from the channel.
// Here we'll receive the "ping" message we sent above and print it out.
while isempty(messages)
    sleep(10);
end
msg = messages(1);
messages(1) = null();
disp(msg);

// Wait for the thread to finish
threadWait(thread_id);

In Scilab, we don’t have built-in channel functionality like in some other languages. However, we can simulate a simple channel-like behavior using global variables and threads. Here’s how the code works:

1. We create a global variable messages as a list to simulate our channel.

2. We define a function sendMessage() that adds the string “ping” to our messages list.

3. We use threadCreate() to start the sendMessage function in a separate thread, simulating concurrent execution.

4. In the main thread, we wait for a message to appear in our messages list using a while loop and sleep().

5. Once a message is available, we retrieve it from the list, remove it, and display it.

6. Finally, we wait for the thread to finish using threadWait().

When we run this program, the “ping” message is successfully passed from one thread to another via our simulated channel.

--> exec('channels.sce', -1)
ping

This example demonstrates a basic form of inter-thread communication in Scilab. While it’s not as elegant as the channel mechanism in some other languages, it provides a way to pass data between concurrent parts of a program.

Remember that Scilab’s threading capabilities are limited compared to some other languages, and this example is a simplification of the concept of channels. In practice, you might need more robust synchronization mechanisms for complex concurrent programs in Scilab.