@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/templates/prompts/realtime.txt

@@ -0,0 +1,219 @@
+You are assisting with real-time systems programming in C.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Target: Real-time operating systems (RTOS) and hard real-time constraints
+
+## Key Rules for Real-Time Systems
+
+### 1. Deterministic Execution
+- Avoid unbounded loops and recursion
+- Use fixed iteration counts or bounded loops
+- Avoid dynamic memory allocation (non-deterministic)
+- Prefer static allocation with known timing
+- Document worst-case execution time (WCET)
+
+### 2. Priority Inversion Avoidance
+- Use priority inheritance mutexes
+- Minimize critical section duration
+- Avoid nested locks when possible
+- Use priority ceiling protocol
+- Document lock ordering
+
+### 3. Deadline Guarantees
+- Calculate and verify task deadlines
+- Use rate-monotonic or deadline-monotonic scheduling
+- Monitor deadline misses
+- Implement timeout mechanisms
+- Log timing violations
+
+### 4. RTOS Patterns
+- Use RTOS primitives (semaphores, mutexes, queues)
+- Follow task priority assignments carefully
+- Use inter-task communication mechanisms
+- Implement watchdog timers
+- Handle task synchronization properly
+
+### 5. No Blocking in Critical Paths
+- Never block in high-priority tasks
+- Use non-blocking algorithms where possible
+- Avoid I/O operations in time-critical code
+- Use lock-free data structures when appropriate
+- Defer non-critical work to lower priority tasks
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: Priority-Based Task Scheduling
+
+```c
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+
+#define HIGH_PRIORITY_TASK    3
+#define MEDIUM_PRIORITY_TASK  2
+#define LOW_PRIORITY_TASK     1
+
+// Shared resource with priority inheritance mutex
+static SemaphoreHandle_t resource_mutex;
+
+void high_priority_task(void *params) {
+    TickType_t last_wake_time = xTaskGetTickCount();
+    const TickType_t period = pdMS_TO_TICKS(10);  // 10ms period
+    
+    while (1) {
+        // Wait for next period (deterministic timing)
+        vTaskDelayUntil(&last_wake_time, period);
+        
+        // Critical section with bounded duration
+        if (xSemaphoreTake(resource_mutex, pdMS_TO_TICKS(5)) == pdTRUE) {
+            // Access shared resource (bounded time)
+            process_critical_data();
+            xSemaphoreGive(resource_mutex);
+        } else {
+            // Deadline miss - log error
+            log_deadline_miss("high_priority_task");
+        }
+    }
+}
+
+void medium_priority_task(void *params) {
+    while (1) {
+        // Non-blocking check for work
+        if (work_available()) {
+            process_work();
+        }
+        vTaskDelay(pdMS_TO_TICKS(20));
+    }
+}
+
+void init_tasks(void) {
+    // Create priority inheritance mutex
+    resource_mutex = xSemaphoreCreateMutex();
+    configASSERT(resource_mutex != NULL);
+    
+    // Create tasks with appropriate priorities
+    xTaskCreate(high_priority_task, "HighPri", 256,
+                NULL, HIGH_PRIORITY_TASK, NULL);
+    xTaskCreate(medium_priority_task, "MedPri", 256,
+                NULL, MEDIUM_PRIORITY_TASK, NULL);
+}
+```
+
+## Example Pattern: Deadline Monitoring
+
+```c
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct {
+    uint32_t period_us;        // Task period in microseconds
+    uint32_t deadline_us;      // Relative deadline
+    uint32_t wcet_us;          // Worst-case execution time
+    uint32_t last_start_us;    // Last execution start time
+    uint32_t missed_deadlines; // Counter for deadline misses
+} task_timing_t;
+
+static task_timing_t task_timing = {
+    .period_us = 10000,    // 10ms period
+    .deadline_us = 9000,   // 9ms deadline
+    .wcet_us = 5000,       // 5ms WCET
+    .missed_deadlines = 0
+};
+
+void time_critical_task(void) {
+    uint32_t start_time = get_microseconds();
+    task_timing.last_start_us = start_time;
+    
+    // Perform time-critical work (bounded)
+    execute_critical_work();
+    
+    uint32_t end_time = get_microseconds();
+    uint32_t execution_time = end_time - start_time;
+    
+    // Check deadline
+    if (execution_time > task_timing.deadline_us) {
+        task_timing.missed_deadlines++;
+        log_error("Deadline miss: %lu us (limit: %lu us)",
+                 execution_time, task_timing.deadline_us);
+    }
+    
+    // Verify WCET assumption
+    if (execution_time > task_timing.wcet_us) {
+        log_warning("WCET exceeded: %lu us (expected: %lu us)",
+                   execution_time, task_timing.wcet_us);
+    }
+}
+```
+
+## Example Pattern: Lock-Free Circular Buffer
+
+```c
+#include <stdint.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+
+#define BUFFER_SIZE 64
+
+typedef struct {
+    uint8_t data[BUFFER_SIZE];
+    atomic_uint head;
+    atomic_uint tail;
+} lockfree_buffer_t;
+
+// Producer (ISR or high-priority task)
+bool buffer_put(lockfree_buffer_t *buf, uint8_t byte) {
+    uint32_t current_head = atomic_load(&buf->head);
+    uint32_t next_head = (current_head + 1) % BUFFER_SIZE;
+    
+    if (next_head == atomic_load(&buf->tail)) {
+        return false;  // Buffer full
+    }
+    
+    buf->data[current_head] = byte;
+    atomic_store(&buf->head, next_head);
+    return true;
+}
+
+// Consumer (lower-priority task)
+bool buffer_get(lockfree_buffer_t *buf, uint8_t *byte) {
+    uint32_t current_tail = atomic_load(&buf->tail);
+    
+    if (current_tail == atomic_load(&buf->head)) {
+        return false;  // Buffer empty
+    }
+    
+    *byte = buf->data[current_tail];
+    atomic_store(&buf->tail, (current_tail + 1) % BUFFER_SIZE);
+    return true;
+}
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Using malloc/free in real-time tasks
+- Unbounded loops or recursion
+- Priority inversion (use priority inheritance)
+- Blocking in high-priority tasks
+- Not monitoring deadline misses
+- Ignoring worst-case execution time
+- Nested locks causing deadlocks
+
+Generate real-time C code following these deterministic standards.
+

package/augment-extensions/coding-standards/c/templates/prompts/systems.txt

@@ -0,0 +1,147 @@
+You are assisting with C systems programming following POSIX standards.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Platform: POSIX-compliant systems (Linux, Unix, macOS, BSD)
+
+## Key Rules for Systems Programming
+
+### 1. POSIX Compliance
+- Use POSIX-defined feature test macros (_POSIX_C_SOURCE, _XOPEN_SOURCE)
+- Follow POSIX API specifications strictly
+- Use standard POSIX types (pid_t, size_t, ssize_t, off_t)
+
+### 2. System Call Error Checking
+**CRITICAL**: ALWAYS check return values of system calls
+- Check for -1 return (most system calls)
+- Use errno for error diagnosis
+- Provide meaningful error messages with perror() or strerror()
+- Handle EINTR (interrupted system calls) by retrying
+
+### 3. Signal Handling
+- Use sigaction() instead of deprecated signal()
+- Make signal handlers async-signal-safe (no printf, malloc, etc.)
+- Use volatile sig_atomic_t for variables shared with signal handlers
+- Block signals during critical sections with sigprocmask()
+
+### 4. Inter-Process Communication (IPC)
+- Choose appropriate IPC: pipes, FIFOs, message queues, shared memory, sockets
+- Synchronize access to shared resources
+- Clean up IPC resources on exit (unlink, close, shmdt)
+- Handle partial reads/writes in loops
+
+### 5. Process Management
+- Check fork() return for all three cases: parent (>0), child (0), error (<0)
+- Use exec() family correctly, check return values
+- Reap child processes with wait()/waitpid() to avoid zombies
+- Handle process termination signals (SIGTERM, SIGCHLD)
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: Safe System Call with Error Handling
+
+```c
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+
+ssize_t safe_write(int fd, const void *buf, size_t count) {
+    ssize_t written = 0;
+    ssize_t result;
+    
+    while (written < count) {
+        result = write(fd, (char*)buf + written, count - written);
+        
+        if (result < 0) {
+            if (errno == EINTR) {
+                continue;  // Interrupted, retry
+            }
+            perror("write");
+            return -1;
+        }
+        
+        written += result;
+    }
+    
+    return written;
+}
+```
+
+## Example Pattern: Proper Signal Handling
+
+```c
+#include <signal.h>
+
+volatile sig_atomic_t got_signal = 0;
+
+void signal_handler(int signo) {
+    got_signal = signo;  // Async-signal-safe
+}
+
+int setup_signals(void) {
+    struct sigaction sa;
+    sa.sa_handler = signal_handler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_RESTART;
+    
+    if (sigaction(SIGINT, &sa, NULL) < 0) {
+        perror("sigaction");
+        return -1;
+    }
+    return 0;
+}
+```
+
+## Example Pattern: Fork and Exec
+
+```c
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+pid_t spawn_process(char *program, char *argv[]) {
+    pid_t pid = fork();
+    
+    if (pid < 0) {
+        perror("fork");
+        return -1;
+    } else if (pid == 0) {
+        // Child process
+        execvp(program, argv);
+        perror("execvp");  // Only reached if exec fails
+        _exit(127);
+    }
+    
+    // Parent process
+    return pid;
+}
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Ignoring system call return values
+- Using signal() instead of sigaction()
+- Not handling EINTR on blocking calls
+- Forgetting to reap child processes
+- Not cleaning up IPC resources
+- Using non-async-signal-safe functions in signal handlers
+
+Generate code following these systems programming standards.
+