git subrepo pull lib/ssm

subrepo:
  subdir:   "lib/ssm"
  merged:   "a9bf527"
upstream:
  origin:   "ssm-runtime"
  branch:   "main"
  commit:   "a9bf527"
git-subrepo:
  version:  "0.4.3"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "2f68596"

Author: j-hui

lib/ssm/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = ssm-runtime
 	branch = main
-	commit = a3eb8f36d0989878f3485f47b7913a222552ca78
-	parent = ce89861d65a11ff7f5a94b89bf2cf8ac3f973db8
+	commit = a9bf5272efed87994389613dd29e8f99bb7465c5
+	parent = bfbde4f3b1727f9a6ffe768391f10c50e3f2fbdb
 	method = merge
 	cmdver = 0.4.3

lib/ssm/Makefile

@@ -65,7 +65,7 @@ $(info PLATFORM is $(PLATFORM))
 COV_TGT := $(BUILD_DIR)/coverage.xml
 
 CC = $(MAKE_CC)
-CFLAGS += -g -I$(INC_DIR) -O -Wall -pedantic
+CFLAGS += -g -I$(INC_DIR) -O -Wall -pedantic $(EXTRA_CFLAGS)
 
 ifeq ($(PLATFORM),simulation)
 # enforce c99 for pure testing, but don't enforce it for other platforms
@@ -74,7 +74,8 @@ endif
 
 ifeq ($(PLATFORM),simulation)
 # Check whether valgrind is available.
-ifeq ($(shell command -v valgrind),)
+# ifeq (0,0)
+ifeq ($(shell which valgrind),)
 $(info # Valgrind is not available; compiling without it.)
 else
 # If available, we try to #include <valgrind/valgrind.h>, which we use to
@@ -87,7 +88,7 @@ CFLAGS += -DUSE_VALGRIND
 endif
 endif
 
-TEST_CFLAGS = $(CFLAGS) -g -DSSM_DEBUG --coverage
+TEST_CFLAGS = $(CFLAGS) -g -DSSM_DEBUG --coverage -DCONFIG_MEM_STATS
 
 LD = $(MAKE_LD)
 LDFLAGS = -L$(BUILD_DIR)
@@ -164,5 +165,7 @@ help:
 	@echo
 	@echo "Available example targets:" $(EXE_TGT)
 	@echo "Available test targets:" $(TEST_TGT)
+	@echo
+	@echo "Specify, e.g., CONFIGS=\"CONFIG_MEM_STATS SSM_DEBUG\" to define additional compilation flags"
 
 .PHONY: $(PHONY)

lib/ssm/doc/Doxyfile

@@ -273,6 +273,9 @@ INCLUDE_FILE_PATTERNS  =
 
 PREDEFINED             += __GNUC__
 PREDEFINED             += UINTPTR_MAX=0xffffffffu
+PREDEFINED             += CONFIG_MEM_STATS
+PREDEFINED             += CONFIG_MEM_TRACE
+PREDEFINED             += CONFIG_MALLOC_HEAP
 
 SKIP_FUNCTION_MACROS   = YES
 

lib/ssm/doc/mem.md

@@ -50,3 +50,12 @@ The allocator's memory pools may be configured using the #SSM_MEM_POOL_MIN,
 preprocessor constants.
 The default values produce 4 memory pools, of sizes 16B, 64B, 256B, and 1024B,
 and a memory page size of 4096B.
+
+The runtime recognizes several compile time configuration macros that help with
+profiling and debugging. They are:
+
+-   CONFIG_MEM_TRACE: log information any time something is allocated or freed.
+-   CONFIG_MEM_STATS: collect statistics and report about memory pool usage.
+-   CONFIG_MALLOC_HEAP: bypass the allocator entirely and allocate everything
+    using malloc(), so that memory accesses can be tracked with Valgrind.
+

lib/ssm/include/ssm-internal.h

@@ -241,6 +241,46 @@ void ssm_mem_destroy(void (*free_page_handler)(void *));
 #define SSM_MEM_PAGE_SIZE SSM_MEM_POOL_SIZE(SSM_MEM_POOL_COUNT)
 #endif
 
+#ifdef CONFIG_MEM_STATS
+
+/** @brief Statistics for a heap page pool; used in #ssm_mem_statistics_t.
+ *
+ *  @note Define CONFIG_MEM_STATS to enable this.
+ */
+typedef struct ssm_mem_statistics_pool {
+  size_t block_size;       /**< Size of this pool's blocks */
+  size_t pages_allocated;  /**< Number of pages allocated to this pool */
+  size_t free_list_length; /**< Length of the free list */
+} ssm_mem_statistics_pool_t;
+
+/** @brief Statistics for the heap; filled with #ssm_mem_statistics_collect().
+ *
+ *  A collection of satistics collected by #ssm_mem_statistics_collect()
+ *  and designed to be printed by a function you supply.
+ *
+ *  @note Define CONFIG_MEM_STATS to enable this.
+ */
+typedef struct ssm_mem_statistics {
+  size_t sizeof_ssm_mm;     /**< Size of per-object memory management header */
+  size_t page_size;         /**< Bytes in a memory page */
+  size_t pages_allocated;   /**< Number of pages that have been allocated */
+  size_t objects_allocated; /**< Total number of allocated objects */
+  size_t objects_freed;     /**< Total number of object free events */
+  size_t live_objects;      /**< Number of live objects **/
+  size_t pool_count;        /**< Number of memory pools */
+  ssm_mem_statistics_pool_t pool[32]; /**< Size of the blocks in each pool */
+} ssm_mem_statistics_t;
+
+/** @brief Collect and return statistics about the heap.
+ *
+ *  @note Define CONFIG_MEM_STATS to enable this.
+ *
+ *  @param stats   non-NULL pointer to a #ssm_mem_statistics_t to be filled in
+ */
+void ssm_mem_statistics_collect(ssm_mem_statistics_t *stats);
+
+#endif /* CONFIG_MEM_STATS */
+
 /** @} */
 
 #ifdef USE_VALGRIND

lib/ssm/include/ssm.h

@@ -14,6 +14,10 @@
 #include <stdint.h>  /* For uint16_t, UINT64_MAX etc. */
 #include <stdlib.h>  /* For size_t */
 
+#ifdef CONFIG_MEM_TRACE
+#include <stdio.h>
+#endif
+
 /**
  * @addtogroup error
  * @{
@@ -169,8 +173,18 @@ typedef struct ssm_trigger {
  *
  *  @throws SSM_EXHAUSTED_MEMORY out of memory.
  */
-ssm_act_t *ssm_enter(size_t size, ssm_stepf_t step, ssm_act_t *parent,
-                     ssm_priority_t priority, ssm_depth_t depth);
+ssm_act_t *ssm_enter_int(size_t size, ssm_stepf_t step, ssm_act_t *parent,
+                         ssm_priority_t priority, ssm_depth_t depth);
+
+#ifdef CONFIG_MEM_TRACE
+#define ssm_enter(si, st, pa, pr, de)                                          \
+  (fprintf(stderr, "%s:%d:ssm_enter(%lu,_,_,_,_,_)\n", __FILE__, __LINE__,     \
+           (si)),                                                              \
+   ssm_enter_int((si), (st), (pa), (pr), (de)))
+#else
+#define ssm_enter(si, st, pa, pr, de)                                          \
+  ssm_enter_int((si), (st), (pa), (pr), (de))
+#endif
 
 /** @brief Destroy the activation record of a routine before leaving.
  *
@@ -426,8 +440,17 @@ ssm_time_t ssm_now(void);
  *
  *  @param time what the heap-allocated @a time field is initialized to.
  *  @returns    #ssm_value_t pointing to the heap-allocated #ssm_time.
+ *
+ *  ssm_value_t ssm_new_time(ssm_time_t time)
  */
-ssm_value_t ssm_new_time(ssm_time_t time);
+extern ssm_value_t ssm_new_time_int(ssm_time_t time);
+#ifdef CONFIG_MEM_TRACE
+#define ssm_new_time(t)                                                        \
+  (fprintf(stderr, "%s:%d:ssm_new_time()\n", __FILE__, __LINE__),              \
+   ssm_new_time_int(t))
+#else
+#define ssm_new_time(t) ssm_new_time_int(t)
+#endif
 
 /** @brief Read the heap-allocated time pointed to by an #ssm_value_t.
  *
@@ -483,7 +506,16 @@ struct ssm_adt1 {
  *  @param tag          the tag of the ADT object, stored in the #ssm_mm header.
  *  @returns            #ssm_value_t poining to the ADT object on the heap.
  */
-ssm_value_t ssm_new_adt(uint8_t field_count, uint8_t tag);
+extern ssm_value_t ssm_new_adt_int(uint8_t field_count, uint8_t tag);
+
+#ifdef CONFIG_MEM_TRACE
+#define ssm_new_adt(fc, tag)                                                   \
+  (fprintf(stderr, "%s:%d:ssm_new_adt(%d, %d)\n", __FILE__, __LINE__, (fc),    \
+           (tag)),                                                             \
+   ssm_new_adt_int((fc), (tag)))
+#else
+#define ssm_new_adt(fc, tag) ssm_new_adt_int((fc), (tag))
+#endif
 
 /** @brief Access the field of an ADT object.
  *
@@ -572,7 +604,14 @@ typedef struct ssm_sv {
  *  @param val  the initial value of the scheduled variable.
  *  @returns    #ssm_value_t pointing to the #ssm_sv on the heap.
  */
-ssm_value_t ssm_new_sv(ssm_value_t val);
+extern ssm_value_t ssm_new_sv_int(ssm_value_t val);
+#ifdef CONFIG_MEM_TRACE
+#define ssm_new_sv(v)                                                          \
+  (fprintf(stderr, "%s:%d:ssm_new_sv()\n", __FILE__, __LINE__),                \
+   ssm_new_sv_int(v))
+#else
+#define ssm_new_sv(v) ssm_new_sv_int(v)
+#endif
 
 /** @brief Retrieve #ssm_sv pointer pointed to by an #ssm_value_t.
  *
@@ -837,7 +876,15 @@ struct ssm_closure1 {
  *  @param arg_cap  the number of arguments the closure should accommodate.
  *  @returns        a value pointing to the heap-allocated closure.
  */
-ssm_value_t ssm_new_closure(ssm_func_t f, uint8_t arg_cap);
+extern ssm_value_t ssm_new_closure_int(ssm_func_t f, uint8_t arg_cap);
+#ifdef CONFIG_MEM_TRACE
+#define ssm_new_closure(f, args)                                               \
+  (fprintf(stderr, "%s:%d:ssm_new_closure(_, %d)\n", __FILE__, __LINE__,       \
+           (args)),                                                            \
+   ssm_new_closure_int((f), (args)))
+#else
+#define ssm_new_closure(f, args) ssm_new_closure_int((f), (args))
+#endif
 
 /** @brief Create a copy of a closure.
  *
@@ -999,7 +1046,16 @@ struct ssm_array1 {
  *  @param count  number of #ssm_value_t elements to be stored in the array.
  *  @returns      #ssm_value_t pointing to heap-allocated array.
  */
-ssm_value_t ssm_new_array(uint16_t count);
+
+extern ssm_value_t ssm_new_array_int(uint16_t count);
+#ifdef CONFIG_MEM_TRACE
+#define ssm_new_array(c)                                                       \
+  (fprintf(stderr,"%s:%d:ssm_new_array(%d)\n", \
+	   __FILE__, __LINE__, (c)),		     \
+   ssm_new_array_int(c)
+#else
+#define ssm_new_array(c) ssm_new_array_int(c)
+#endif
 
 /** @} */
 
@@ -1048,7 +1104,8 @@ struct ssm_blob1 {
  *  @param size   scaled size of the blob's payload.
  *  @returns      size that a blob of @a size payload occupies in the heap.
  */
-#define ssm_blob_size(size) (sizeof(struct ssm_blob1) + (size)-SSM_BLOB_SIZE_SCALE)
+#define ssm_blob_size(size)                                                    \
+  (sizeof(struct ssm_blob1) - SSM_BLOB_SIZE_SCALE + (size))
 
 /** @brief Compute the size a blob in the heap.
  *
@@ -1067,7 +1124,14 @@ struct ssm_blob1 {
  *  @param size   size of the payload to the allocated.
  *  @returns      #ssm_value_t pointing to heap-allocated blob.
  */
-ssm_value_t ssm_new_blob(uint16_t size);
+extern ssm_value_t ssm_new_blob_int(uint16_t size);
+#ifdef CONFIG_MEM_TRACE
+#define ssm_new_blob(s)                                                        \
+  (fprintf(stderr, "%s:%d:ssm_new_blob(%lu)\n", __FILE__, __LINE__, (size)),   \
+   ssm_new_blob_int(size))
+#else
+#define ssm_new_blob(s) ssm_new_blob_int(s)
+#endif
 
 /** @} */
 

lib/ssm/platform/posix/src/posix-io.c

@@ -17,10 +17,16 @@ static void step_stdout_handler(ssm_act_t *act) {
   case 1:;
     char c = ssm_unmarshal(ssm_deref(cont->ssm_stdout));
     if (!c)
-      break;
+      return;
     write(1, &c, 1);
     return;
+  case 2:; // Magical "terminate self" code
+    break;
   }
+
+  ssm_desensitize(
+      &cont->trigger); // sensitize added a pointer to the activation record
+  ssm_drop(cont->ssm_stdout); // Caller drop this argument
   ssm_leave(&cont->act, sizeof(stdout_handler_act_t));
 }