demake 0.2.0 → 0.2.1

data/lib/data/libsrc/cpu_mark_check.h

@@ -0,0 +1,267 @@
+/*
+
+  cpu_mark_check.h -- *Full Library* Header File for Inline CPU Profiling
+
+  See the end of this file for an example.
+
+  Public Functions:
+
+  i32 cpu_mark_new(const c8 *description);
+  void cpu_mark_check(i32 index, i32 limit);
+  void cpu_mark_new_description(i32 index, const c8 *description);
+  void cpu_mark_reset(i32 index);
+  void cpu_mark_remove(i32 index);
+
+*/
+
+#ifndef CPU_MARK_CHECK_H_Minaswan	/* Prevents multiple inclusions	*/
+#define CPU_MARK_CHECK_H_Minaswan
+  #define CPU_MARK_CHECK_VERSION	"0.1.0"
+  #ifndef TYPEDEFS_H_Minaswan		/* Header guard for typedefs.h	*/
+    #define TYPEDEFS_H_Minaswan
+    #include <stdint.h>
+    typedef uint8_t b8;			/* Booleans */
+    typedef uint16_t b16;
+    typedef uint32_t b32;
+    typedef uint64_t b64;
+
+    typedef char c8;                    /* Characters */
+    typedef unsigned char uc8;
+
+    typedef uint8_t u8;                 /* Unsigned Numbers */
+    typedef uint16_t u16;
+    typedef uint32_t u32;
+    typedef uint64_t u64;
+
+    typedef int8_t i8;                  /* Signed Numbers */
+    typedef int16_t i16;
+    typedef int32_t i32;
+    typedef int64_t i64;
+
+    typedef float f32;                  /* Floating Point Numbers */
+    typedef double f64;
+  #endif				/* TYPEDEFS_H_Minaswan */
+
+  /* Public Functions */
+  i32 cpu_mark_new(const c8 *description);
+  void cpu_mark_check(i32 index, i32 limit);
+  void cpu_mark_new_description(i32 index, const c8 *description);
+  void cpu_mark_reset(i32 index);
+  void cpu_mark_remove(i32 index);
+
+  #ifdef CPU_MARK_CHECK_IMPLEMENTATION
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <time.h>
+    #include <sys/time.h>
+
+    #ifndef FALSE
+      #define FALSE                       0
+    #endif
+
+    #ifndef TRUE
+      #define TRUE                        1
+    #endif
+
+    #ifndef NULL
+      #define NULL                        ((void *) 0)
+    #endif
+
+    #define CPU_MARK_DEFAULT_USEC		1000
+
+    struct cpu_mark_time {
+      i32      index;
+      u64      threshold;
+      const c8 *description;
+      struct   timeval last;
+      struct   cpu_mark_time *next;
+    };
+
+    struct cpu_mark_time *cpu_mark_list = NULL;
+
+    i32 cpu_mark_next_index(void)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+      i32 index = 0;
+
+      for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+        if(cpu_mark->index >= index)
+          index = cpu_mark->index;
+      }
+      index++;
+
+      return(index);
+    }
+
+    i32 cpu_mark_new(const c8 *description)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      cpu_mark = (struct cpu_mark_time *)calloc(1, sizeof(struct cpu_mark_time));
+      cpu_mark->index = cpu_mark_next_index();
+      if(description && *description)
+        cpu_mark->description = description;
+      else
+        cpu_mark->description = "No Description";
+      cpu_mark->next = cpu_mark_list;
+      cpu_mark_list = cpu_mark;
+      gettimeofday(&cpu_mark->last, (struct timezone *) 0);
+
+      return(cpu_mark->index);
+    }
+
+    void cpu_mark_remove(i32 index)
+    {
+      struct cpu_mark_time *cpu_mark = NULL, *next_cpu_mark = NULL;
+
+      if(cpu_mark_list && cpu_mark_list->index == index) {
+        cpu_mark = cpu_mark_list;
+        cpu_mark_list = cpu_mark->next;
+        free(cpu_mark);
+      } else if(cpu_mark_list) {
+        for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+          if(cpu_mark->next && cpu_mark->next->index == index) {
+            next_cpu_mark = cpu_mark->next;
+            cpu_mark->next = next_cpu_mark->next;
+            free(next_cpu_mark);
+          }
+        }
+      }
+    }
+
+    void cpu_mark_reset(i32 index)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+        if(cpu_mark->index == index) {
+          gettimeofday(&cpu_mark->last, (struct timezone *) 0);
+        }
+      }
+    }
+
+    struct cpu_mark_time *cpu_mark_find_by_index(i32 index)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      for(cpu_mark = cpu_mark_list; cpu_mark; cpu_mark = cpu_mark->next) {
+        if(cpu_mark->index == index)
+          return(cpu_mark);
+      }
+
+      return(NULL);
+    }
+
+    void cpu_mark_new_description(i32 index, const c8 *description)
+    {
+      struct cpu_mark_time *cpu_mark = NULL;
+
+      cpu_mark = cpu_mark_find_by_index(index);
+
+      if(cpu_mark) {
+        if(description && *description)
+          cpu_mark->description = description;
+        else
+          cpu_mark->description = "No Description";
+      }
+    }
+
+    struct timeval cpu_mark_subtract_time(struct timeval *time1, struct timeval *time2)
+    {
+      struct timeval difference, no_time;
+
+      no_time.tv_sec = 0;
+      no_time.tv_usec = 0;
+
+      if(time1->tv_sec < time2->tv_sec)
+        return no_time;
+      else if(time1->tv_sec == time2->tv_sec) {
+        if(time1->tv_usec < time2->tv_usec)
+          return no_time;
+        else {
+          difference.tv_sec = 0;
+          difference.tv_usec = time1->tv_usec - time2->tv_usec;
+          return difference;
+        }
+      } else {
+        difference.tv_sec = time1->tv_sec - time2->tv_sec;
+        if(time1->tv_usec < time2->tv_usec) {
+          difference.tv_usec = time1->tv_usec + 1000000 - time2->tv_usec;
+          difference.tv_sec--;
+        } else
+          difference.tv_usec = time1->tv_usec - time2->tv_usec;
+        return difference;
+      }
+      return no_time;
+    }
+
+    void cpu_mark_check(i32 index, i32 limit)
+    {
+      struct cpu_mark_time *cpu_mark = cpu_mark_find_by_index(index);
+      struct timeval current, spent;
+      c8 local_buf[1024];
+      c8 local_buf2[1024];
+
+      if(!cpu_mark)
+        return;
+
+      gettimeofday(&current, (struct timezone *) 0);
+      spent = cpu_mark_subtract_time(&current, &cpu_mark->last);
+      if(spent.tv_sec || spent.tv_usec > limit) {
+        sprintf(local_buf2, "CPU Threshold (%d): ", cpu_mark->index);
+        strcat(local_buf2, cpu_mark->description);
+        printf("%s\r\n", local_buf2);
+        sprintf(local_buf2, "CPU Threshold (%d): ", cpu_mark->index);
+        if(spent.tv_sec) {
+          sprintf(local_buf, " secs = %ld", spent.tv_sec);
+          strcat(local_buf2, local_buf);
+        }
+        if(spent.tv_usec) {
+          sprintf(local_buf, " usecs = %ld", spent.tv_usec);
+          strcat(local_buf2, local_buf);
+        }
+        printf("%s\r\n", local_buf2);
+      }
+    }
+  #endif /* CPU_MARK_CHECK_IMPLEMENTATION */
+#endif /* CPU_MARK_CHECK_H_Minaswan */
+
+/*
+  Example:
+
+  #define CPU_MARK_CHECK_IMPLEMENTATION
+  #include "cpu_mark_check.h"
+
+  i32 mark1 = cpu_mark_new("Startup");
+
+  i32 i = 0, j = 0, k = 0;
+  for(i = 0; i < 100000; i++)	// Perform "startup" work
+    j += i;
+  k += j;
+  printf("k = %d\n", k);	// So compiler won't optimize out testing
+  cpu_mark_check(mark1, 0);	// If it's been more than 0 msec print mark time
+
+  cpu_mark_reset(mark1);	// Reset counter to start "main" work
+  // Could also just create new if we wanted "startup" to keep going
+  // i32 mark2 = cpu_mark_new("Main Working");
+
+  cpu_mark_new_description(mark1, "Main Working");
+  j = 0;
+  for(i = 0; i < 100000; i++)	// Perform "main" work
+    j += i;
+  k += j;
+  printf("k = %d\n", k);
+  cpu_mark_check(mark1, 0);	// If it's been more than 0 msec print mark time
+
+  cpu_mark_new_description(mark1, "Main Still Working");
+  j = 0;
+  for(i = 0; i < 100000; i++)	// Perform more "main" work
+    j += i;
+  k += j;
+  printf("k = %d\n", k);
+  cpu_mark_check(mark1, 0);	// If it's been more than 0 msec print mark time
+
+  cpu_mark_remove(mark1);
+
+*/

data/lib/data/libsrc/defines.h

@@ -0,0 +1,29 @@
+/*
+   defines.h -- Basic C preprocessor macro definitions
+*/
+
+#ifndef DEFINES_H_Minaswan	/* Header guard to prevent multiple inclusions */
+  #define DEFINES_H_Minaswan
+  #define DEFINES_VERSION	"0.1.0"
+  #ifndef NULL
+    #define NULL		((void *) 0)
+  #endif
+  #ifndef FALSE
+    #define FALSE		0
+  #endif
+  #ifndef TRUE
+    #define TRUE		1
+  #endif
+  #ifndef NO
+    #define NO			0
+  #endif
+  #ifndef YES
+    #define YES			1
+  #endif
+  #ifndef OFF
+    #define OFF			0
+  #endif
+  #ifndef ON
+    #define ON			1
+  #endif
+#endif /* DEFINES_H_Minaswan */

data/lib/data/libsrc/fast_read_file.h

@@ -0,0 +1,259 @@
+/*
+
+  fast_read_file.h -- *Full Library* Header File
+
+  For reading the entire contents of a file into 64-bit aligned memory.
+
+  See the end of this file for examples.
+
+  Public Functions:     ** DON'T FORGET TO FREE YOUR MEMORY AFTER USE **
+
+  c8 *fast_read_all_file_mapped(FILE *file, u64 *total_bytes);  ** READ ONLY **
+  void free_all_mapped_read_memory(c8 *data, u64 *total_bytes);
+
+  c8 *fast_read_all_file_aligned(FILE *file, u64 *total_bytes); ** READ/WRITE **
+  void free_all_aligned_read_memory(c8 *data);
+
+*/
+
+#ifndef FAST_READ_FILE_H_Minaswan	/* Prevent multiple inclusions	*/
+#define FAST_READ_FILE_H_Minaswan
+  #define FAST_READ_FILE_VERSION	"0.1.0"
+  #ifndef TYPEDEFS_H_Minaswan		/* Header guard for typedefs.h	*/
+    #define TYPEDEFS_H_Minaswan
+    #include <stdint.h>
+    typedef uint8_t b8;			/* Booleans			*/
+    typedef uint16_t b16;
+    typedef uint32_t b32;
+    typedef uint64_t b64;
+
+    typedef char c8;			/* Characters			*/
+    typedef unsigned char uc8;
+
+    typedef uint8_t u8;			/* Unsigned Numbers		*/
+    typedef uint16_t u16;
+    typedef uint32_t u32;
+    typedef uint64_t u64;
+
+    typedef int8_t i8;			/* Signed Numbers		*/
+    typedef int16_t i16;
+    typedef int32_t i32;
+    typedef int64_t i64;
+
+    typedef float f32;			/* Floating Point Numbers	*/
+    typedef double f64;
+  #endif				/* TYPEDEFS_H_Minaswan		*/
+
+  #include <stdio.h>
+
+  /* Public Functions */
+  void free_all_mapped_read_memory(c8 *data, u64 *total_bytes);
+  void free_all_aligned_read_memory(c8 *data);
+  c8 *fast_read_all_file_mapped(FILE *file, u64 *total_bytes);
+  c8 *fast_read_all_file_aligned(FILE *file, u64 *total_bytes);
+
+  #ifdef FAST_READ_FILE_IMPLEMENTATION	/* Effectively read_all_file.c	*/
+    #include <stdlib.h>
+    #include <string.h>
+    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      #include <windows.h>
+    #else
+      #include <sys/mman.h>
+      #include <sys/stat.h>
+      #include <fcntl.h>
+      #include <unistd.h>
+    #endif
+
+    extern i32 fileno(FILE *stream);
+
+    #define FAST_READ_FILE_BUFFER_SIZE	4096
+
+    #ifndef FALSE
+      #define FALSE			0
+    #endif
+
+    #ifndef TRUE
+      #define TRUE			1
+    #endif
+
+    #ifndef NULL
+      #define NULL			((void *) 0)
+    #endif
+
+    #ifndef MIN
+      #define MIN(a, b)			((a) < (b) ? a : b)
+    #endif
+
+    void *fast_file_align64_malloc(size_t size)
+    {
+      void *result = NULL;
+
+      if(size == 0)
+        return(NULL);
+    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      result = _aligned_malloc(size, 64);
+    #else
+      #if(defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
+          (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
+        if(posix_memalign(&result, 64, size) != 0)
+          return(NULL);
+      #else
+        result = malloc(size);
+      #endif
+    #endif
+      return(result);
+    }
+
+    void *fast_file_align64_calloc(size_t size)
+    {
+      void *result = fast_file_align64_malloc(size);
+
+      if(result)
+        memset(result, 0, size);
+      return(result);
+    }
+
+    void *fast_file_align64_realloc(void *existing_memory, size_t old_size, size_t new_size)
+    {
+      void *new_memory = fast_file_align64_calloc(new_size);
+
+      if(new_memory && existing_memory) {
+        memcpy(new_memory, existing_memory, MIN(new_size, old_size));
+        free(existing_memory);
+        return(new_memory);
+      }
+      return(NULL);
+    }
+
+    c8 *fast_read_all_file_aligned(FILE *file, u64 *total_bytes)
+    {
+      size_t bytes = 0, count = 0;
+      c8 buffer[FAST_READ_FILE_BUFFER_SIZE + 1];
+      c8 *data = NULL;
+
+      bytes = fread(buffer, sizeof(c8), FAST_READ_FILE_BUFFER_SIZE, file);
+      while(bytes) {
+        if(data) {
+          data = fast_file_align64_realloc(data, *total_bytes + 1, *total_bytes + bytes + 1);
+          count = 0;
+          while(count < bytes) {
+            *(data + *total_bytes + count) = buffer[count];
+            count++;
+          }
+        } else {
+          data = fast_file_align64_calloc(bytes + 1);
+          count = 0;
+          while(count < bytes) {
+            *(data + *total_bytes + count) = buffer[count];
+            count++;
+          }
+        }
+        *total_bytes += (u32)bytes;
+        *(data + *total_bytes) = '\0';
+        bytes = fread(buffer, sizeof(c8), FAST_READ_FILE_BUFFER_SIZE, file);
+      }
+      return(data);
+    }
+
+    c8 *fast_read_all_file_mapped(FILE *file, u64 *total_bytes)
+    {
+      c8 *data = NULL;
+    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      HANDLE windows_file_handle = {0};
+      HANDLE windows_map_handle = {0};
+      LARGE_INTEGER windows_file_size = {0};
+    #else
+      i32 file_descriptor = fileno(file);
+      struct stat st = {0};
+    #endif
+
+    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      windows_file_handle = (HANDLE)_get_osfhandle(fileno(file));
+      if(windows_file_handle == INVALID_HANDLE_VALUE)
+        return(NULL);
+      if(!GetFileSizeEx(windows_file_handle, &windows_file_size) ||
+          windows_file_size.QuadPart == 0) {
+        CloseHandle(windows_file_handle);
+        return(NULL);
+      }
+      *total_bytes = (u64)windows_file_size.QuadPart;
+      windows_map_handle = CreateFileMapping(windows_file_handle,
+          NULL, PAGE_READONLY, 0, 0, NULL);
+      data = MapViewOfFile(windows_map_handle, FILE_MAP_READ, 0, 0, 0);
+      CloseHandle(windows_file_handle);
+      CloseHandle(windows_map_handle);
+    #else
+      if(file_descriptor == -1)
+        return(NULL);
+      if(fstat(file_descriptor, &st) == -1 || st.st_size == 0) {
+        close(file_descriptor);
+        return(NULL);
+      }
+      *total_bytes = (u64)st.st_size;
+      data = mmap(NULL, *total_bytes, PROT_READ, MAP_PRIVATE,
+          file_descriptor, 0);
+      if(data == MAP_FAILED) {
+        close(file_descriptor);
+        return(NULL);
+      }
+      #ifdef POSIX_FADV_SEQUENTIAL
+        posix_fadvise(file_descriptor, 0, (i64)*total_bytes,
+            POSIX_FADV_SEQUENTIAL);
+      #endif
+      #ifdef MADV_SEQUENTIAL
+        madvise(data, *total_bytes, MADV_SEQUENTIAL);
+      #endif
+      close(file_descriptor);
+    #endif
+      return(data);
+    }
+
+    void free_all_mapped_read_memory(c8 *data, u64 *total_bytes)
+    {
+    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      UnmapViewOfFile(data);
+    #else
+      munmap(data, *total_bytes);
+    #endif
+    }
+
+    void free_all_aligned_read_memory(c8 *data)
+    {
+    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+      _aligned_free(data);
+    #else
+      free(data);
+    #endif
+    }
+  #endif /* FAST_READ_FILE_IMPLEMENTATION */
+#endif /* FAST_READ_FILE_H_Minaswan */
+
+/*
+
+  Examples:      ** DON'T FORGET TO FREE YOUR MEMORY AFTER USE **
+
+  #define FAST_READ_FILE_IMPLEMENTATION
+  #include "fast_read_file.h"
+
+  // Read everything from file example:
+
+  FILE *file = fopen(argv[1], "rb");
+  u64 total_bytes = 0;
+  c8 *data = fast_read_all_file_mapped(file, &total_bytes);
+  use(string);
+  free_all_mapped_read_memory(string);	// Note: Doesn't use malloc/free
+
+  // Read everything from stdin / non-kernal mapping example:
+
+  u64 total_bytes = 0;
+  c8 *data = fast_read_all_file_aligned(stdin, &total_bytes);
+  use(string);
+  free_all_aligned_read_memory(string);	// Note: Might not use malloc/free
+
+  FILE *file = fopen(argv[1], "rb");
+  u64 total_bytes = 0;
+  c8 *data = fast_read_all_file_aligned(file, &total_bytes);
+  use(string);
+  free_all_aligned_read_memory(string);	// Note: Might not use malloc/free
+
+*/