Add the libc less example app version

Author: tom-kuchler

functions/CMakeLists.txt

@@ -81,6 +81,7 @@ add_subdirectory(basic)
 add_subdirectory(busy)
 add_subdirectory(matmac)
 add_subdirectory(matmul)
+add_subdirectory(example_app_nolibc)
 # dependent on dlibc
 if(USE_LIBC)
   # add_subdirectory(image_processing)

functions/dirigent_busy/dirigent_busy.c

@@ -10,54 +10,76 @@
 #include "unistd.h"
 
 int main(int argc, char const *argv[]) {
-  // parse input
-  FILE* input_data = fopen("/input/input.csv", "r"); 
-  FILE* output_data = fopen("/output/output.csv", "w+");
-  char* workload = NULL;
-  size_t workload_size = 0;
-  if(getdelim(&workload, &workload_size, ',', input_data) < 0) {
-    perror("failed to read workload");
-    return -1;
-  }
-  char* function = NULL;
-  size_t function_size = 0;
-  ssize_t string_len = 0;
-  if((string_len = getdelim(&function, &function_size, ',', input_data) < 0)) {
-    perror("failed to read function");
-    return -1;
-  }
-  // remove ',' from end
-  function[string_len-1] = 0;
-
-  char* requestedCpu = NULL;
-  size_t requestedCpu_size = 0;
-  if(getdelim(&requestedCpu, &requestedCpu_size, ',', input_data) < 0) {
-    perror("failed to read requestedCpu");
-    return -1;
-  }
-  char* multiplier = NULL;
-  size_t multiplier_size = 0;
-  if(getdelim(&multiplier, &multiplier_size, ',', input_data) < 0) {
-    perror("failed to read multiplier");
-    return -1;
-  }
-
-  char* trace_string = "trace";
-  char* empyt_string = "empty";
-  char is_trace = 0;
-  if (strcmp(trace_string, function) == 0){
-    is_trace = 1;
-    long multiplier_num = strtol(multiplier, NULL, 10);
-    double result = 0.0;
-    volatile double input = 10.0;
-    for(long iteration = 0; iteration < multiplier_num; iteration++){
-      result = sqrt(input);
+    // parse input
+    FILE *input_data = fopen("/input/input.csv", "r");
+    if (input_data == NULL) {
+      perror("could not open /input/input.csv");
+      return -1;
+    }
+    FILE *output_data = fopen("/output/output.csv", "w+");
+    if (output_data == NULL) {
+      perror("could not open /output/output.csv");
+      return -1;
+    }
+ 
+    char *workload = NULL;
+    size_t workload_size = 0;
+    if (getdelim(&workload, &workload_size, ',', input_data) < 0) {
+        perror("failed to read workload");
+        return -1;
+    }
+    workload[strlen(workload) - 1] = '\0';
+
+    char *function = NULL;
+    size_t function_size = 0;
+    if (getdelim(&function, &function_size, ',', input_data) < 0) {
+        perror("failed to read function");
+        return -1;
+    }
+    function[strlen(function) - 1] = '\0';
+
+    char *requestedCpu = NULL;
+    size_t requestedCpu_size = 0;
+    if (getdelim(&requestedCpu, &requestedCpu_size, ',', input_data) < 0) {
+        perror("failed to read requestedCpu");
+        return -1;
+    }
+    requestedCpu[strlen(requestedCpu) - 1] = '\0';
+
+    char *multiplier = NULL;
+    size_t multiplier_size = 0;
+    if (getdelim(&multiplier, &multiplier_size, ',', input_data) < 0) {
+        perror("failed to read multiplier");
+        return -1;
     }
-    fprintf(output_data,"\"OK\",\"%s\",\"dandelionServer\",%ld",function, multiplier_num); 
-    return 0;
-  } else if(strcmp(empyt_string, function) == 0) {
-    fprintf(output_data, "\"OK - EMPTY\",\"dandelionServer\",\"%s\",0", function);
-    return 0;
-  }
-  return -1;
+
+    char *trace_string = "trace";
+    char *empyt_string = "empty";
+
+    if (strcmp(trace_string, function) == 0) {
+        long multiplier_num = strtol(multiplier, NULL, 10);
+        long requested_cpu_num = strtol(requestedCpu, NULL, 10);
+
+        long total_iterations = multiplier_num * requested_cpu_num;
+
+	//printf("%ld, %ld, %ld\n", multiplier_num, requested_cpu_num, total_iterations);
+
+        volatile double result = 0.0;
+        volatile double input = 10.0;
+	    volatile long iteration;
+        for (iteration = 0; iteration < total_iterations; iteration++) {
+            result = sqrt(input);
+        }
+
+        fprintf(output_data, "\"OK\",\"%s\",\"dandelionServer\",%ld,%f", function, iteration, result);
+
+        return 0;
+    } else if (strcmp(empyt_string, function) == 0) {
+        fprintf(output_data, "\"OK - EMPTY\",\"dandelionServer\",\"%s\",0", function);
+
+        return 0;
+    }
+
+    return -1;
+
 }

functions/example_app_nolibc/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION ${CMAKE_VERSION})
+
+set(HANDLE "handle_nolibc")
+set(FAN_OUT "fan_out_nolibc")
+set(TEMPLATE "template_nolibc")
+
+add_executable(${HANDLE}
+  handle.c
+)
+add_executable(${FAN_OUT}
+  fan_out.c
+)
+add_executable(${TEMPLATE}
+  template.c
+)
+
+target_compile_options(${HANDLE} PRIVATE -static -O3)
+target_link_options(${HANDLE} PRIVATE -static)
+target_link_libraries(${HANDLE} PRIVATE
+dandelion_runtime
+)
+
+target_compile_options(${FAN_OUT} PRIVATE -static -O3)
+target_link_options(${FAN_OUT} PRIVATE -static)
+target_link_libraries(${FAN_OUT} PRIVATE
+dandelion_runtime
+)
+
+target_compile_options(${TEMPLATE} PRIVATE -static -O3)
+target_link_options(${TEMPLATE} PRIVATE -static)
+target_link_libraries(${TEMPLATE} PRIVATE
+dandelion_runtime
+)

functions/example_app_nolibc/commons.h

@@ -0,0 +1,61 @@
+#include <stdint.h>
+
+#include "dandelion/crt.h"
+#include "dandelion/runtime.h"
+
+const char CHAR_NUMBERS[10] = {'0', '1', '2', '3', '4',
+                               '5', '6', '7', '8', '9'};
+
+int string_copy(char* target, char* source) {
+  size_t read_chars = 0;
+  while (source[read_chars] != '\0') {
+    target[read_chars] = source[read_chars];
+    read_chars++;
+  }
+  return read_chars;
+}
+
+int copy_to_string_end(char* target, char* source) {
+  size_t read_chars = 0;
+  while (source[read_chars] != '\"') {
+    target[read_chars] = source[read_chars];
+    read_chars++;
+  }
+  target[read_chars] = '\\';
+  return read_chars;
+}
+
+int skip_string(char* target, char* comparison) {
+  size_t read_chars = 0;
+  while (comparison[read_chars] != '\0') {
+    if (comparison[read_chars] != target[read_chars]) return -1;
+    read_chars++;
+  }
+  return read_chars;
+}
+
+int errprint(char* message) {
+  if (dandelion_output_set_count() < 1) {
+    return -99;
+  }
+  char* stderr = dandelion_alloc(128, 8);
+  size_t message_index = 0;
+  for (; message[message_index] != '\0' && message_index < 127;
+       message_index++) {
+    stderr[message_index] = message[message_index];
+  }
+  stderr[message_index] = '\0';
+
+  const char stderr_ident[] = "stderr";
+  struct io_buffer stderr_buffer = {
+      .ident = stderr_ident,
+      .ident_len = 7,
+      .data = stderr,
+      .data_len = message_index + 1,
+      .key = 0,
+  };
+
+  dandelion_add_output(0, stderr_buffer);
+
+  return -1;
+}

functions/example_app_nolibc/fan_out.c

@@ -0,0 +1,99 @@
+#include "commons.h"
+
+const unsigned int SERVER_NUMBER = 10;
+
+int main() {
+  // make sure we have the expected output sets
+  if (dandelion_output_set_count() < 1) return -7;
+
+  // read authorization server file
+  if (dandelion_input_set_count() < 2) errprint("have less than 2 input set");
+  if (dandelion_input_buffer_count(0) != 1)
+    errprint("have no buffer in input set 0");
+  if (dandelion_input_buffer_count(1) != 1)
+    errprint("have no buffer in input set 1");
+
+  struct io_buffer* server_file = dandelion_get_input(0, 0);
+  char* server_data = server_file->data;
+  size_t server_len = server_file->data_len;
+
+  struct io_buffer* auth_file = dandelion_get_input(1, 0);
+  char* auth_data = auth_file->data;
+  size_t auth_len = auth_file->data_len;
+
+  // find username
+  size_t user_start = 0;
+  char user_prefix[] = "{\"authorized\":\"";
+  for (size_t prefix_index = user_start; user_prefix[prefix_index] != '\0';
+       prefix_index++) {
+    if (auth_data[user_start] != user_prefix[prefix_index]) {
+      return errprint("user_prefix not in actual auth message");
+    }
+    user_start++;
+  }
+
+  size_t user_end = user_start;
+  while (auth_data[user_end] != '\"' && user_end < auth_len) {
+    user_end++;
+  }
+
+  if (SERVER_NUMBER > 99)
+    return errprint("More than 99 servers, need different formatting");
+  for (size_t server_index = 0; server_index < SERVER_NUMBER; server_index++) {
+    char* request_buffer = dandelion_alloc(2048, 8);
+    size_t request_index = 0;
+    char* server_name = dandelion_alloc(16, 8);
+    char server_prefix[] = "server_";
+    int server_name_end = string_copy(server_name, server_prefix);
+    size_t decimal = server_index / 10;
+    size_t digit = server_index - 10 * decimal;
+    server_name[server_name_end] = CHAR_NUMBERS[decimal];
+    server_name_end++;
+    server_name[server_name_end] = CHAR_NUMBERS[digit];
+    server_name_end++;
+
+    char get_prefix[] = "GET http://";
+    request_index += string_copy(request_buffer + request_index, get_prefix);
+
+    for (size_t line_index = 0;
+         line_index < server_len &&
+         (server_data[line_index] != '\n' || server_data[line_index] != '\0');
+         line_index++) {
+      request_buffer[request_index] = server_data[line_index];
+      request_index++;
+    }
+
+    char log_string[] = "/logs/";
+    request_index += string_copy(request_buffer + request_index, log_string);
+
+    request_buffer[request_index] = CHAR_NUMBERS[decimal];
+    request_index++;
+    request_buffer[request_index] = CHAR_NUMBERS[digit];
+    request_index++;
+
+    char get_suffix[] = " HTTP/1.1\n\n{\"username\": \"";
+    request_index += string_copy(request_buffer + request_index, get_suffix);
+
+    // copy username
+    for(size_t user_index = user_start; user_index < user_end; user_index++){
+      request_buffer[request_index] = auth_data[user_index];
+      request_index++;
+    }
+
+    char json_suffix[] = "\"}";
+    request_index += string_copy(request_buffer + request_index, json_suffix);
+
+    struct io_buffer request = {
+        .ident = server_name,
+        .ident_len = server_name_end,
+        .data = request_buffer,
+        .data_len = request_index,
+        .key = 0,
+    };
+    dandelion_add_output(1, request);
+  } 
+
+  return 0;
+}
+
+DANDELION_ENTRY(main)