wip

Signed-off-by: Mateusz Front <[email protected]>

Author: mat-hek

src/libAtomVM/globalcontext.c

@@ -62,6 +62,8 @@ struct RegisteredProcess
 
 GlobalContext *globalcontext_new(void)
 {
+    printf("DUPA %d\n", REF_SIZE);
+    printf("DUPA %d\n", TERM_BOXED_PROCESS_REF_SIZE);
     GlobalContext *glb = malloc(sizeof(GlobalContext));
     if (IS_NULL_PTR(glb)) {
         return NULL;

src/libAtomVM/nifs.c

@@ -1142,7 +1142,7 @@ static NativeHandlerResult process_console_message(Context *ctx, term msg)
 {
     // msg is not in the port's heap
     NativeHandlerResult result = NativeContinue;
-    if (UNLIKELY(memory_ensure_free_opt(ctx, 12, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+    if (UNLIKELY(memory_ensure_free_opt(ctx, 13, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
         fprintf(stderr, "Unable to allocate sufficient memory for console driver.\n");
         AVM_ABORT();
     }
@@ -1160,7 +1160,7 @@ static NativeHandlerResult process_console_message(Context *ctx, term msg)
         term pid = term_get_tuple_element(msg, 1);
         term ref = term_get_tuple_element(msg, 2);
         term req = term_get_tuple_element(msg, 3);
-        uint64_t ref_ticks = term_to_ref_ticks(ref);
+        RefData ref_data = term_to_ref_data(ref);
 
         if (is_tagged_tuple(req, PUT_CHARS_ATOM, 3)) {
             term chars = term_get_tuple_element(req, 2);
@@ -1170,7 +1170,7 @@ static NativeHandlerResult process_console_message(Context *ctx, term msg)
                 printf("%s", str);
                 free(str);
 
-                term refcopy = term_from_ref_ticks(ref_ticks, &ctx->heap);
+                term refcopy = term_from_ref_data(ref_data, &ctx->heap);
 
                 term reply = term_alloc_tuple(3, &ctx->heap);
                 term_put_tuple_element(reply, 0, IO_REPLY_ATOM);
@@ -4204,7 +4204,7 @@ static term nif_erlang_fun_info_2(Context *ctx, int argc, term argv[])
             RAISE_ERROR(BADARG_ATOM);
     }
 
-    if (UNLIKELY(memory_ensure_free_with_roots(ctx, TUPLE_SIZE(2), 2, (term[]){ key, value }, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
+    if (UNLIKELY(memory_ensure_free_with_roots(ctx, TUPLE_SIZE(2), 2, (term[]) { key, value }, MEMORY_CAN_SHRINK) != MEMORY_GC_OK)) {
         RAISE_ERROR(OUT_OF_MEMORY_ATOM);
     }
     term fun_info_tuple = term_alloc_tuple(2, &ctx->heap);

src/libAtomVM/term.h

@@ -152,7 +152,7 @@ extern "C" {
 #define BOXED_FUN_SIZE 3
 #define FLOAT_SIZE (sizeof(float_term_t) / sizeof(term) + 1)
 #define REF_SIZE ((int) ((sizeof(uint64_t) / sizeof(term)) + 1))
-#define TERM_BOXED_PROCESS_REF_SIZE (REF_SIZE + 1)
+#define TERM_BOXED_PROCESS_REF_SIZE 5
 #define TERM_BOXED_PROCESS_REF_HEADER (((TERM_BOXED_PROCESS_REF_SIZE - 1) << 6) | TERM_BOXED_REF)
 #if TERM_BYTES == 8
 #define EXTERNAL_PID_SIZE 3
@@ -248,6 +248,14 @@ extern "C" {
 typedef struct GlobalContext GlobalContext;
 #endif
 
+typedef struct RefData RefData;
+
+struct RefData
+{
+    uint64_t ref_ticks;
+    int32_t process_id;
+};
+
 typedef struct PrinterFun PrinterFun;
 
 typedef int (*printer_function_t)(PrinterFun *fun, const char *fmt, ...) PRINTF_FORMAT_ARGS(2, 3);
@@ -1896,7 +1904,7 @@ static inline bool term_is_nomatch_binary_pos_len(BinaryPosLen pos_len)
 
 static inline BinaryPosLen term_nomatch_binary_pos_len(void)
 {
-    return (BinaryPosLen){ .pos = -1, .len = -1 };
+    return (BinaryPosLen) { .pos = -1, .len = -1 };
 }
 
 /**
@@ -1999,7 +2007,7 @@ static inline term term_make_process_reference(int32_t process_id, uint64_t ref_
     boxed_value[0] = TERM_BOXED_PROCESS_REF_HEADER;
 
 #if TERM_BYTES == 4
-    boxed_value[1] = (ref_ticks >> 4);
+    boxed_value[1] = (ref_ticks >> 32);
     boxed_value[2] = (ref_ticks & 0xFFFFFFFF);
     boxed_value[3] = process_id;
 
@@ -2027,6 +2035,23 @@ static inline uint32_t term_process_ref_to_process_id(term rt)
 #endif
 }
 
+static inline RefData term_to_ref_data(term t)
+{
+    RefData ref_data;
+    ref_data.ref_ticks = term_to_ref_ticks(t);
+    ref_data.process_id = term_is_process_reference(t) ? term_process_ref_to_process_id(t) : 0;
+    return ref_data;
+}
+
+static inline term term_from_ref_data(RefData ref_data, Heap *heap)
+{
+    if (ref_data.process_id) {
+        return term_make_process_reference(ref_data.process_id, ref_data.ref_ticks, heap);
+    } else {
+        return term_from_ref_ticks(ref_data.ref_ticks, heap);
+    }
+}
+
 /**
  * @brief Make an external pid term from node, process_id, serial and creation
  *

src/platforms/esp32/components/avm_builtins/network_driver.c

@@ -58,7 +58,7 @@
 #define TCPIP_HOSTNAME_MAX_SIZE 255
 
 #define TAG "network_driver"
-#define PORT_REPLY_SIZE (TUPLE_SIZE(2) + REF_SIZE)
+#define PORT_REPLY_SIZE (TUPLE_SIZE(2) + TERM_BOXED_PROCESS_REF_SIZE)
 
 static const char *const ap_atom = ATOM_STR("\x2", "ap");
 static const char *const ap_channel_atom = ATOM_STR("\xA", "ap_channel");
@@ -110,7 +110,7 @@ struct ClientData
     GlobalContext *global;
     uint32_t port_process_id;
     uint32_t owner_process_id;
-    uint64_t ref_ticks;
+    RefData ref_data;
 };
 
 static inline term make_atom(GlobalContext *global, AtomString atom_str)
@@ -131,7 +131,7 @@ static term tuple_from_addr(Heap *heap, uint32_t addr)
 
 static void send_term(Heap *heap, struct ClientData *data, term t)
 {
-    term ref = term_from_ref_ticks(data->ref_ticks, heap);
+    term ref = term_from_ref_data(data->ref_data, heap);
     term msg = term_alloc_tuple(2, heap);
     term_put_tuple_element(msg, 0, ref);
     term_put_tuple_element(msg, 1, t);
@@ -659,7 +659,7 @@ static void start_network(Context *ctx, term pid, term ref, term config)
     data->global = ctx->global;
     data->port_process_id = ctx->process_id;
     data->owner_process_id = term_to_local_process_id(pid);
-    data->ref_ticks = term_to_ref_ticks(ref);
+    data->ref_data = term_to_ref_data(ref);
 
     esp_err_t err;
 
@@ -890,7 +890,7 @@ static NativeHandlerResult consume_mailbox(Context *ctx)
         return NativeContinue;
     }
 
-    //TODO: port this code to standard port (and gen_message)
+    // TODO: port this code to standard port (and gen_message)
     term pid = term_get_tuple_element(msg, 0);
     term ref = term_get_tuple_element(msg, 1);
     term cmd = term_get_tuple_element(msg, 2);
@@ -922,7 +922,7 @@ static NativeHandlerResult consume_mailbox(Context *ctx)
             default: {
                 ESP_LOGE(TAG, "Unrecognized command: %x", cmd);
                 // {Ref, {error, badarg}}
-                size_t heap_size = TUPLE_SIZE(2) + REF_SIZE + TUPLE_SIZE(2);
+                size_t heap_size = TUPLE_SIZE(2) + TERM_BOXED_PROCESS_REF_SIZE + TUPLE_SIZE(2);
                 if (UNLIKELY(memory_ensure_free(ctx, heap_size) != MEMORY_GC_OK)) {
                     ESP_LOGE(TAG, "Unable to allocate heap space for error; no message sent");
                     return NativeContinue;
@@ -932,7 +932,7 @@ static NativeHandlerResult consume_mailbox(Context *ctx)
         }
     } else {
         // {Ref, {error, badarg}}
-        size_t heap_size = TUPLE_SIZE(2) + REF_SIZE + TUPLE_SIZE(2);
+        size_t heap_size = TUPLE_SIZE(2) + TERM_BOXED_PROCESS_REF_SIZE + TUPLE_SIZE(2);
         if (UNLIKELY(memory_ensure_free(ctx, heap_size) != MEMORY_GC_OK)) {
             ESP_LOGE(TAG, "Unable to allocate heap space for error; no message sent");
             return NativeContinue;