Recieves with long delay and lacks cb

Author: EhsanKhodadad

lfc/core/src/main/kotlin/org/lflang/generator/uc/UcNetworkChannel.kt

@@ -398,16 +398,15 @@ class UcCoapUdpIpChannel(
 class UcS4NocChannel(
     src: UcS4NocEndpoint,
     dest: UcS4NocEndpoint,
-    serverLhs: Boolean = true,
-) : UcNetworkChannel(S4NOC, src, dest, serverLhs) {
+) : UcNetworkChannel(S4NOC, src, dest, false) {
   private val srcS4Noc = src
   private val destS4Noc = dest
 
   override fun generateChannelCtorSrc() =
-      "S4NOCPollChannel_ctor(&self->channel, ${if (serverLhs) srcS4Noc.core else destS4Noc.core});"
+      "S4NOCPollChannel_ctor(&self->channel, ${srcS4Noc.core});"
 
   override fun generateChannelCtorDest() =
-      "S4NOCPollChannel_ctor(&self->channel, ${if (serverLhs) srcS4Noc.core else destS4Noc.core});"
+      "S4NOCPollChannel_ctor(&self->channel, ${destS4Noc.core});"
 
   override val codeType: String
     get() = "S4NOCPollChannel"

make/patmos/patmos.mk

@@ -34,4 +34,5 @@ CFLAGS += -Wall -Wextra
 CFLAGS += -DPLATFORM_PATMOS 
 CFLAGS += -DNETWORK_CHANNEL_S4NOC 
 CFLAGS += -DSCHEDULER_DYNAMIC
-CFLAGS += -DFEDERATED
+CFLAGS += -DFEDERATED
+CFLAGS += -DLF_LOG_LEVEL_ALL=LF_LOG_LEVEL_DEBUG

src/platform/patmos/patmos.c

@@ -3,6 +3,7 @@
 #include <stdbool.h>
 #include <string.h>
 #include <reactor-uc/environment.h>
+#include "reactor-uc/logging.h"
 
 #include <machine/rtc.h>
 #include <machine/exceptions.h>
@@ -20,21 +21,13 @@ instant_t PlatformPatmos_get_physical_time(Platform *super) {
 
 lf_ret_t PlatformPatmos_wait_until_interruptible(Platform *super, instant_t wakeup_time) {
   PlatformPatmos *self = (PlatformPatmos *)super;
-  self->async_event = false;
 
   instant_t now = super->get_physical_time(super);
 
   // Do busy sleep
   do {
     now = super->get_physical_time(super);
-  } while ((now < wakeup_time) && !self->async_event);
-
-  if (self->async_event) {
-    self->async_event = false;
-    return LF_ERR;
-  } else {
-    return LF_OK;
-  }
+  } while (now < wakeup_time);
 
   interval_t sleep_duration = wakeup_time - super->get_physical_time(super);
   if (sleep_duration < 0) {
@@ -96,6 +89,7 @@ void Platform_ctor(Platform *super) {
   super->wait_until_interruptible = PlatformPatmos_wait_until_interruptible;
   super->notify = PlatformPatmos_notify;
   self->num_nested_critical_sections = 0;
+  LF_DEBUG(PLATFORM, "PlatformPatmos initialized");
 }
 
 Platform *Platform_new(void) {

src/platform/patmos/s4noc_channel.c

@@ -45,6 +45,8 @@ static lf_ret_t S4NOCPollChannel_send_blocking(NetworkChannel *untyped_self, con
     *((int *)self->write_buffer) = message_size;
     S4NOC_CHANNEL_DEBUG("S4NOCPollChannel_send_blocking: message size: ((%d)).", message_size);
     int total_size = message_size + 4;
+    S4NOC_CHANNEL_DEBUG("Total size to send: ((%d))", total_size);
+
     *s4noc_dest = self->destination_core;
     int bytes_send = 0;
     while (bytes_send < total_size) {
@@ -62,7 +64,7 @@ static void S4NOCPollChannel_register_receive_callback(NetworkChannel *untyped_s
                                                        void (*receive_callback)(FederatedConnectionBundle *conn,
                                                                                 const FederateMessage *msg),
                                                        FederatedConnectionBundle *conn) {
-  // S4NOC_CHANNEL_INFO("Register receive callback at %p", receive_callback);
+  S4NOC_CHANNEL_INFO("Register receive callback at %p", receive_callback);
   S4NOCPollChannel *self = (S4NOCPollChannel *)untyped_self;
 
   self->receive_callback = receive_callback;
@@ -98,15 +100,16 @@ void S4NOCPollChannel_poll(NetworkChannel *untyped_self) {
                                                receive_channel->receive_buffer + 4, // skip the 4-byte size header
                                                expected_message_size                // only the message payload
     );
+    // bytes_left = ((bytes_left / 4)+1) * 4;
     // S4NOC_CHANNEL_DEBUG("Bytes Left after attempted to deserialize: %d", bytes_left);
 
     if (bytes_left >= 0) {
       receive_channel->receive_buffer_index = bytes_left;
       if (receive_channel->receive_callback != NULL) {
-        // S4NOC_CHANNEL_DEBUG("calling user callback at %p!", receive_channel->receive_callback);
+        S4NOC_CHANNEL_DEBUG("calling user callback at %p!", receive_channel->receive_callback);
         receive_channel->receive_callback(self->federated_connection, &receive_channel->output);
       } else {
-        // S4NOC_CHANNEL_WARN("No receive callback registered, dropping message");
+        S4NOC_CHANNEL_WARN("No receive callback registered, dropping message");
       }
     }
   }

src/schedulers/dynamic/scheduler.c

@@ -298,6 +298,7 @@ void Scheduler_run(Scheduler *untyped_self) {
     }
 
     if (env->poll_network_channels) {
+      LF_DEBUG(SCHED, "Polling network channels");
       env->poll_network_channels(env);
     }
 

test/platform/patmos/s4noc_channel_test/Makefile

@@ -9,8 +9,6 @@ BUILD_DIR = $(CURDIR)/build
 # Source files
 SOURCES += $(SRC_DIR)/$(APP).c 
 
-CFLAGS += -DLF_LOG_LEVEL_ALL=LF_LOG_LEVEL_DEBUG
-
 # Output binary
 OUTPUT = $(BUILD_DIR)/$(APP).elf
 all : $(OUTPUT)

test/platform/patmos/s4noc_channel_test/main.c

@@ -8,7 +8,7 @@
 #define MESSAGE_CONNECTION_ID 42
 #define SOURCE_CORE 1
 #define DESTINATION_CORE 2
-#define MAX_TRIES 10
+#define MAX_TRIES 20
 
 Reactor parent;
 FederatedEnvironment fed_env;