rpc_lesson2

Three models run in a client-server, remote procedure call (RPC) communication pattern. The two client models (client1 & client2) send requests and receive response to/from the server model server via the deprecated call method. The server model receives requests and send responses. This example demostrates the RPC pattern through the use of the client_of and is_server model parameters and the RPC interface classes/functions. The client1 & client2 models also send request/response pairs to files in the temporary directory and receive parameters via the command line as specified in the YAML (both model call the same source code). The server model receives parameters as input from a file.

C Version

Model Code:

#include "YggInterface.h"
#include <stdio.h>


int get_fibonacci(int n) {
  int pprev = 0, prev = 1, result = 1, fib_no = 1;
  while (fib_no < n) {
    result = prev + pprev;
    pprev = prev;
    prev = result;
    fib_no = fib_no + 1;
  }
  return result;
};


int main(int argc, char *argv[]) {
  
  int exit_code = 0;
  printf("Hello from C server!\n");

  // Create server-side rpc conneciton using model name
  yggRpc_t rpc = yggRpcServer("server", "%d", "%d");

  // Continue receiving requests until the connection is closed when all
  // clients have disconnected.
  int flag, n, result;
  while (1) {
    printf("server(C): receiving...\n");
    flag = rpcRecv(rpc, &n);
    if (flag < 0) {
      printf("server(C): end of input\n");
      break;
    }

    // Compute fibonacci number
    printf("server(C): Received request for Fibonacci number %d\n", n);
    result = get_fibonacci(n);
    printf("server(C): Sending response for Fibonacci number %d: %d\n",
	   n, result);

    // Send response back
    flag = rpcSend(rpc, result);
    if (flag < 0) {
      printf("server(C): ERROR sending\n");
      exit_code = -1;
      break;
    }
  }

  printf("Goodbye from C server\n");
  return exit_code;
};

#include "YggInterface.h"
#include <stdio.h>


int main(int argc, char *argv[]) {
   
  int iterations = atoi(argv[1]);
  int client_index = atoi(argv[2]);
  int exit_code = 0;
  printf("Hello from C client%d: iterations %d\n",
	 client_index, iterations);
  
  // Set up connections matching yaml
  // RPC client-side connection will be $(server_name)_$(client_name)
  char rpc_name[100];
  char log_name[100];
  sprintf(rpc_name, "server_client%d", client_index);
  sprintf(log_name, "output_log%d", client_index);
  yggRpc_t rpc = yggRpcClient(rpc_name, "%d", "%d");
  yggOutput_t log = yggOutputFmt(log_name, "fib(%-2d) = %-2d\n");

  // Initialize variables
  int ret = 0;
  int fib = -1;
  int i;

  // Iterate over Fibonacci sequence
  for (i = 1; i <= iterations; i++) {
    
    // Call the server and receive response
    printf("client%d(C): Calling fib(%d)\n", client_index, i);
    ret = rpcCall(rpc, i, &fib);
    if (ret < 0) {
      printf("client%d(C): RPC CALL ERROR\n", client_index);
      exit_code = -1;
      break;
    }
    printf("client%d(C): Response fib(%d) = %d\n", client_index, i, fib);

    // Log result by sending it to the log connection
    ret = yggSend(log, i, fib);
    if (ret < 0) {
      printf("client%d(C): SEND ERROR\n", client_index);
      exit_code = -1;
      break;
    }
  }

  printf("Goodbye from C client%d\n", client_index);
  return exit_code;
    
}

Model YAML:

---

model:
  name: server
  language: c
  args: ./src/server.c
  is_server: True  # Creates a RPC server queue called "server"

---

models:
  - name: client1
    language: c
    args:
      - ./src/client.c
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: c
    args:
      - ./src/client.c
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true

C++ Version

Model Code:

#include "YggInterface.hpp"
#include <stdio.h>


int get_fibonacci(int n) {
  int pprev = 0, prev = 1, result = 1, fib_no = 1;
  while (fib_no < n) {
    result = prev + pprev;
    pprev = prev;
    prev = result;
    fib_no = fib_no + 1;
  }
  return result;
};


int main(int argc, char *argv[]) {
  
  int exit_code = 0;
  printf("Hello from C++ server!\n");

  // Create server-side rpc conneciton using model name
  YggRpcServer rpc("server", "%d", "%d");

  // Continue receiving requests until the connection is closed when all
  // clients have disconnected.
  int flag, n, result;
  while (1) {
    printf("server(C++): receiving...\n");
    flag = rpc.recv(1, &n);
    if (flag < 0) {
      printf("server(C++): end of input\n");
      break;
    }

    // Compute fibonacci number
    printf("server(C++): Received request for Fibonacci number %d\n", n);
    result = get_fibonacci(n);
    printf("server(C++): Sending response for Fibonacci number %d: %d\n",
	   n, result);

    // Send response back
    flag = rpc.send(1, result);
    if (flag < 0) {
      printf("server(C++): ERROR sending\n");
      exit_code = -1;
      break;
    }
  }

  printf("Goodbye from C++ server\n");
  return exit_code;
};

#include "YggInterface.hpp"
#include <stdio.h>


int main(int argc, char *argv[]) {
   
  int iterations = atoi(argv[1]);
  int client_index = atoi(argv[2]);
  int exit_code = 0;
  printf("Hello from C++ client%d: iterations %d\n",
	 client_index, iterations);
  
  // Set up connections matching yaml
  // RPC client-side connection will be $(server_name)_$(client_name)
  char rpc_name[100];
  char log_name[100];
  sprintf(rpc_name, "server_client%d", client_index);
  sprintf(log_name, "output_log%d", client_index);
  YggRpcClient rpc(rpc_name, "%d", "%d");
  YggOutput log(log_name, "fib(%-2d) = %-2d\n");
  
  // Initialize variables
  int ret = 0;
  int fib = -1;
  char *logmsg = (char*)malloc(YGG_MSG_MAX*sizeof(char));
  int i;

  // Iterate over Fibonacci sequence
  for (i = 1; i <= iterations; i++) {
    
    // Call the server and receive response
    printf("client%d(C++): Calling fib(%d)\n", client_index, i);
    ret = rpc.call(2, i, &fib);
    if (ret < 0) {
      printf("client%d(C++): RPC CALL ERROR\n", client_index);
      exit_code = -1;
      break;
    }
    printf("client%d(C++): Response fib(%d) = %d\n", client_index, i, fib);

    // Log result by sending it to the log connection
    ret = log.send(2, i, fib);
    if (ret < 0) {
      printf("client%d(C++): SEND ERROR\n", client_index);
      exit_code = -1;
      break;
    }
  }

  free(logmsg);
  printf("Goodbye from C++ client%d\n", client_index);
  return exit_code;
}

Model YAML:

---

model:
  name: server
  language: c++
  args: ./src/server.cpp
  is_server: True  # Creates a RPC server queue called "server"

---

models:
  - name: client1
    language: c++
    args:
      - ./src/client.cpp
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: c++
    args:
      - ./src/client.cpp
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true

Fortran Version

Model Code:

program main
  use fygg

  interface
     function get_fibonacci(n) result(out)
       integer, intent(in) :: n
       integer :: out
     end function get_fibonacci
  end interface

  type(yggcomm) :: rpc
  logical :: ret
  integer :: fib, n
  integer :: exit_code = 0

  write(*, '("Hello from Fortran server!")')

  ! Create server-side rpc conneciton using model name
  rpc = ygg_rpc_server("server", "%d", "%d")

  ! Initialize variables
  ret = .true.
  fib = -1

  ! Continue receiving requests until the connection is closed when all
  ! clients have disconnected.
  do while (.TRUE.)
     write(*, '("server(F): receiving...")')
     ret = ygg_recv_var(rpc, yggarg(n))
     if (.not.ret) then
        write(*, '("server(F): end of input")')
        exit
     end if

     ! Compute fibonacci number
     write(*, '("server(F): Received request for Fibonacci number ",i2)') n
     fib = get_fibonacci(n)
     write(*, '("server(F): Sending response for Fibonacci number ",i2,": ",i2)') n, fib

     ! Send response back
     ret = ygg_send_var(rpc, yggarg(fib))
     if (.not.ret) then
        write(*, '("server(F): ERROR sending")')
        exit_code = -1;
        exit;
     end if
  end do

  write(*, '("Goodbye from Fortran server")')
  if (exit_code.lt.0) then
     stop 1
  end if

end program main

function get_fibonacci(n) result(out)
  integer, intent(in) :: n
  integer :: out
  integer :: pprev, prev, fib_no
  pprev = 0
  prev = 1
  out = 1
  fib_no = 1
  do while (fib_no < n)
     out = prev + pprev
     pprev = prev
     prev = out
     fib_no = fib_no + 1
  end do
end function get_fibonacci

program main
  use fygg

  character(len=32) :: arg
  integer :: iterations, client_index
  type(yggcomm) :: rpc
  type(yggcomm) :: log
  logical :: ret
  integer :: fib, i
  integer :: exit_code = 0
  character(len=100) :: rpc_name
  character(len=100) :: log_name

  call get_command_argument(1, arg)
  read(arg, *) iterations
  call get_command_argument(2, arg)
  read(arg, *) client_index
  write(*, '("Hello from Fortran client",i1,": iterations ",i2)') &
       client_index, iterations

  ! Set up connections matching yaml
  ! RPC client-side connection will be $(server_name)_$(client_name)
  write(rpc_name, '("server_client",i1)') client_index
  write(log_name, '("output_log",i1)') client_index
  rpc = ygg_rpc_client(trim(rpc_name), "%d", "%d")
  log = ygg_output_fmt(trim(log_name), "fib(%-2d) = %-2d\n")

  ! Initialize variables
  ret = .true.
  fib = -1

  ! Iterate over Fibonacci sequence
  do i = 1, iterations

     ! Call the server and receive response
     write(*, '("client",i1,"(F): Calling fib(",i2,")")') &
          client_index, i
     ret = ygg_rpc_call(rpc, yggarg(i), yggarg(fib))
     if (.not.ret) then
        write(*, '("client",i1,"(F): RPC CALL ERROR")') client_index
        exit_code = -1;
        exit
     end if
     write(*, '("client",i1,"(F): Response fib(",i2,") = ",i2)') &
          client_index, i, fib

     ! Log result by sending it to the log connection
     ret = ygg_send_var(log, [yggarg(i), yggarg(fib)])
     if (.not.ret) then
        write(*, '("client",i1,"(F): SEND ERROR")') client_index
        exit_code = -1
        exit
     end if

  end do

  write(*, '("Goodbye from Fortran client",i1)') client_index
  if (exit_code.lt.0) then
     stop 1
  end if

end program main

Model YAML:

---

model:
  name: server
  language: fortran
  args: ./src/server.f90
  is_server: True  # Creates a RPC server queue called "server"

---

models:
  - name: client1
    language: fortran
    args:
      - ./src/client.f90
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: fortran
    args:
      - ./src/client.f90
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true

Julia Version

Model Code:

using Yggdrasil
using Printf


function get_fibonacci(n)
  global pprev = 0
  global prev = 1
  global result = 1
  global fib_no = 1
  while (fib_no < n)
    global result = prev + pprev
    global pprev = prev
    global prev = result
    global fib_no = fib_no + 1
  end
  return Int64(result)
end


function main()

  println("Hello from Julia server!")

  # Create server-side rpc conneciton using model name
  rpc = Yggdrasil.YggInterface("YggRpcServer", "server", "%d", "%d")

  # Continue receiving requests until the connection is closed when all
  # clients have disconnected.
  while (true)
    println("server(Julia): receiving...")
    retval, rpc_in = rpc.recv()
    if (!retval)
      println("server(Julia): end of input")
      break
    end

    # Compute fibonacci number
    n = rpc_in[1]
    @printf("server(Julia): Received request for Fibonacci number %d\n", n)
    result = get_fibonacci(n)
    @printf("server(Julia): Sending response for Fibonacci number %d: %d\n", n, result)

    # Send response back
    flag = rpc.send(result)
    if (!flag)
      error("server(Julia): ERROR sending")
    end
  end
  
  println("Goodbye from Julia server")
end

main()

using Yggdrasil
using Printf


function main(iterations, client_index)
    
  @printf("Hello from Julia client: iterations = %d\n", iterations)

  # Set up connections matching yaml
  # RPC client-side connection will be $(server_name)_$(client_name)
  rpc = Yggdrasil.YggInterface("YggRpcClient", @sprintf("server_client%d", client_index), "%d", "%d")
  log = Yggdrasil.YggInterface("YggOutput", @sprintf("output_log%d", client_index), "fib(%-2d) = %-2d\n")

  # Iterate over Fibonacci sequence
  for i = 1:iterations
        
    # Call the server and receive response
    @printf("client%d(Julia): Calling fib(%d)\n", client_index, i)
    ret, result = rpc.call(i)
    if (!ret)
      error(@sprintf("client%d(Julia): RPC CALL ERROR", client_index))
    end
    fib = result[1]
    @printf("client%d(Julia): Response fib(%d) = %d\n", client_index, i, fib)

    # Log result by sending it to the log connection
    ret = log.send(i, fib)
    if (!ret)
      error(@sprintf("client%d(Julia): SEND ERROR", client_index))
    end
  end

  @printf("Goodbye from Julia client%d\n", client_index)
end

    
main(parse(Int64, ARGS[1]), parse(Int64, ARGS[2]))

Model YAML:

---

model:
  name: server
  language: julia
  args: ./src/server.jl
  is_server: True  # Creates a RPC server queue called "server"

---

models:
  - name: client1
    language: julia
    args:
      - ./src/client.jl
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: julia
    args:
      - ./src/client.jl
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true

Matlab Version

Model Code:

function server()
  
  disp('Hello from Matlab server!');

  % Create server-side rpc conneciton using model name
  rpc = YggInterface('YggRpcServer', 'server', '%d', '%d');

  % Continue receiving requests until the connection is closed when all
  % clients have disconnected.
  while true
    disp('server(M): receiving...');
    [retval, rpc_in] = rpc.recv();
    if (~retval);
      disp('server(M):end of input');
      break;
    end;

    % Compute fibonacci number
    n = rpc_in{1};
    fprintf('server(M): Received request for Fibonacci number %d\n', n);
    pprev = 0;
    prev = 1;
    result = 1;
    fib_no = 1;
    while fib_no < n
      result = prev + pprev;
      pprev = prev;
      prev = result;
      fib_no = fib_no + 1;
    end;
    fprintf('server(M): Sending response for Fibonacci number %d: %d\n', n, result);

    % Send response back
    flag = rpc.send(int32(result));
    if (~flag);
      error('server(M): ERROR sending');
    end;
  end;

  disp('Goodbye from Matlab server');
  
end

function client(iterations, client_index)
  
  iterations = str2num(iterations);
  client_index = str2num(client_index);
  fprintf('Hello from Matlab client%d: iterations = %d\n', ...
          client_index, iterations);

  % Set up connections matching yaml
  % RPC client-side connection will be $(server_name)_$(client_name)
  rpc_name = sprintf('server_client%d', client_index);
  log_name = sprintf('output_log%d', client_index);
  rpc = YggInterface('YggRpcClient', rpc_name, '%d', '%d');
  log = YggInterface('YggOutput', log_name, 'fib(%-2d) = %-2d\n');

  % Iterate over Fibonacci sequence
  for i = 1:iterations
    
    % Call the server and receive response
    fprintf('client%d(Matlab): Calling fib(%d)\n', client_index, i);
    [ret, result] = rpc.call(int32(i));
    if (~ret);
      error(sprintf('client%d(Matlab): RPC CALL ERROR\n', client_index));
    end;
    fib = result{1};
    fprintf('client%d(Matlab): Response fib(%d) = %d\n', client_index, ...
            i, fib);

    % Log result by sending it to the log connection
    ret = log.send(int32(i), fib);
    if (~ret);
      error(sprintf('client%d(Matlab): SEND ERROR\n', client_index));
    end;
  end;

  fprintf('Goodbye from Matlab client%d\n', client_index);
  
end

Model YAML:

---

model:
  name: server
  language: matlab
  args: ./src/server.m
  is_server: True  # Creates a RPC server queue called "server"

---

models:
  - name: client1
    language: matlab
    args:
      - ./src/client.m
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: matlab
    args:
      - ./src/client.m
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true

Python Version

Model Code:

import numpy as np
from yggdrasil.interface.YggInterface import YggInput, YggRpcServer


def get_fibonacci(n):
    r"""Compute the nth number of the Fibonacci sequence.

    Args:
        n (int): Index of the Fibonacci number in the Fibonacci sequence that
            should be returned.

    Returns:
        int: The nth Fibonacci number.

    """
    pprev = 0
    prev = 1
    result = 1
    fib_no = 1
    while fib_no < n:
        result = prev + pprev
        pprev = prev
        prev = result
        fib_no = fib_no + 1
    return result


def main():
    r"""Function to execute server communication and computation in a loop."""

    print('Hello from Python server!')

    # Get parameters
    inp = YggInput("params")
    retval, params = inp.recv()
    if not retval:
        raise RuntimeError('server: ERROR receiving parameters')
    print('server: Parameters = %s' % params)

    # Create server-side rpc conneciton using model name
    rpc = YggRpcServer("server", "%d", "%d")

    # Continue receiving requests until the connection is closed when all
    # clients have disconnected.
    while True:
        print('server: receiving...')
        retval, rpc_in = rpc.recv()
        if not retval:
            print('server: end of input')
            break

        # Compute fibonacci number
        n = rpc_in[0]
        print('server: Received request for Fibonacci number %d' % n)
        result = get_fibonacci(n)
        print('server: Sending response for Fibonacci number %d: %d' % (n, result))

        # Send response back
        flag = rpc.send(np.int32(result))
        if not flag:
            raise RuntimeError('server: ERROR sending')

    print('Goodbye from Python server')

    
if __name__ == '__main__':
    main()

import sys
import numpy as np
from yggdrasil.interface.YggInterface import (
    YggRpcClient, YggOutput)


def main(iterations, client_index):
    r"""Function to execute client communication with server that computes
    numbers in the Fibonacci sequence.

    Args:
        iterations (int): The number of Fibonacci numbers to log.
        client_index (int): Index of the client in total list of clients.

    """

    print('Hello from Python client%d: iterations = %d ' % (client_index,
                                                            iterations))

    # Set up connections matching yaml
    # RPC client-side connection will be $(server_name)_$(client_name)
    rpc = YggRpcClient("server_client%d" % client_index, "%d", "%d")
    log = YggOutput("output_log%d" % client_index, 'fib(%-2d) = %-2d\n')

    # Iterate over Fibonacci sequence
    for i in range(1, iterations + 1):
        
        # Call the server and receive response
        print('client%d(Python): Calling fib(%d)' % (client_index, i))
        ret, result = rpc.call(np.int32(i))
        if not ret:
            raise RuntimeError('client%d(Python): RPC CALL ERROR' % client_index)
        fib = result[0]
        print('client%d(Python): Response fib(%d) = %d' % (client_index, i, fib))

        # Log result by sending it to the log connection
        ret = log.send(np.int32(i), fib)
        if not ret:
            raise RuntimeError('client%d(Python): SEND ERROR' % client_index)

    print('Goodbye from Python client%d' % client_index)

    
if __name__ == '__main__':
    # Take number of iterations from the first argument and the
    # client index from the second
    main(int(sys.argv[1]), int(sys.argv[2]))

Model YAML:

---

model:
  name: server
  language: python
  args: ./src/server.py
  is_server: True  # Creates a RPC server queue called "server"
  inputs:
    name: params
    default_file:
      name: ./Input/server_params.txt
      filetype: ascii

---

models:
  - name: client1
    language: python
    args:
      - ./src/client.py
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: python
    args:
      - ./src/client.py
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true

R Version

Model Code:

library(yggdrasil)


get_fibonacci <- function(n) {
  pprev = 0
  prev = 1
  result = 1
  fib_no = 1
  while (fib_no < n) {
    result = prev + pprev
    pprev = prev
    prev = result
    fib_no = fib_no + 1
  }
  return(as.integer(result))
}


main <- function() {

  fprintf('Hello from R server!')

  # Create server-side rpc conneciton using model name
  rpc <- YggInterface('YggRpcServer', "server", "%d", "%d")

  # Continue receiving requests until the connection is closed when all
  # clients have disconnected.
  while (1) {
    fprintf('server(R): receiving...')
    c(retval, rpc_in) %<-% rpc$recv()
    if (!retval) {
      fprintf('server(R): end of input')
      break
    }

    # Compute fibonacci number
    n = rpc_in[[1]]
    fprintf('server(R): Received request for Fibonacci number %d', n)
    result = get_fibonacci(n)
    fprintf('server(R): Sending response for Fibonacci number %d: %d', n, result)

    # Send response back
    flag <- rpc$send(result)
    if (!flag) {
      stop('server(R): ERROR sending')
    }
    
  }

  print('Goodbye from R server')
}

main()

library(yggdrasil)


main <- function(iterations, client_index) {

  fprintf('Hello from Python client: iterations = %d ', iterations)

  # Set up connections matching yaml
  # RPC client-side connection will be $(server_name)_$(client_name)
  rpc <- YggInterface('YggRpcClient',
                      sprintf("server_client%d", client_index), "%d", "%d")
  log <- YggInterface('YggOutput',
                      sprintf("output_log%d", client_index), 'fib(%-2d) = %-2d\n')

  # Iterate over Fibonacci sequence
  for (i in 1:iterations) {
        
    # Call the server and receive response
    fprintf('client%d(R): Calling fib(%d)', client_index, i)
    c(ret, result) %<-% rpc$call(i)
    if (!ret) {
      stop(sprintf('client%d(R): RPC CALL ERROR', client_index))
    }
    fib <- result[[1]]
    fprintf('client%d(R): Response fib(%d) = %d', client_index, i, fib)

    # Log result by sending it to the log connection
    ret <- log$send(i, fib)
    if (!ret) {
      stop(sprintf('client%d(R): SEND ERROR', client_index))
    }
  }

  fprintf('Goodbye from R client%d', client_index)
}


args = commandArgs(trailingOnly=TRUE)
main(strtoi(args[[1]]), strtoi(args[[2]]))

Model YAML:

---

model:
  name: server
  language: R
  args: ./src/server.R
  is_server: True  # Creates a RPC server queue called "server"

---

models:
  - name: client1
    language: R
    args:
      - ./src/client.R
      - 3  # Pass the number of iterations that should be performed
      - 1  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log1
  - name: client2
    language: R
    args:
      - ./src/client.R
      - 5  # Pass the number of iterations that should be performed
      - 2  # Pass index of the client
    client_of: server  # Creates an RPC client queue "server_client"
    outputs: output_log2

connections:
  - input: output_log1
    output: client_output1.txt
    in_temp: true
  - input: output_log2
    output: client_output2.txt
    in_temp: true