synthemesc-codex 0.0.0

data/.gitignore

@@ -0,0 +1,8 @@
+codex
+.DS_Store
+*.map
+build/*
+*.o
+*.bundle
+*.log
+Makefile

data/Makefile.server

@@ -0,0 +1,47 @@
+# -*- Mode: Makefile; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+#
+# Makefile for 'codex'.
+#
+# Type 'make' or 'make codex' to create the binary.
+# Type 'make clean' to delete all temporaries.
+# Type 'make run' to execute the binary.
+# Type 'make debug' to debug the binary using gdb(1).
+#
+
+# build target specs
+CC = cc
+CFLAGS = -O3 -pipe -fPIC -fomit-frame-pointer -fno-common \
+  -Wall -Wshadow -Wpointer-arith \
+# -march=native -mcpu=native -mtune=native
+
+LIBS = -levent 
+
+# first target entry is the target invoked when typing 'make'
+default: codex.c.o vm.c.o tpl.c.o
+	@echo -n 'Increasing build number in build.h... '
+	@awk '!/define CODEX_BUILD/ {print} /define CODEX_BUILD/ {print "#define CODEX_BUILD\t"$$3+1}' build.h > build.h~
+	@mv build.h~ build.h
+	@echo Done.
+	@echo -n 'Linking codex... '
+	@$(CC) $(CFLAGS) -o codex codex.c.o vm.c.o tpl.c.o $(LIBS)
+	@echo Done.
+
+codex.c.o: codex.c
+	@echo -n 'Compiling codex.c... '
+	@$(CC) $(CFLAGS) -o codex.c.o -c codex.c
+	@echo Done.
+
+vm.c.o: vm.c
+	@echo -n 'Compiling vm.c... '
+	@$(CC) $(CFLAGS) -o vm.c.o -c vm.c
+	@echo Done.
+
+tpl.c.o: tpl.c
+	@echo -n 'Compiling tpl.c... '
+	@$(CC) $(CFLAGS) -o tpl.c.o -c tpl.c
+	@echo Done.
+
+clean:
+	@echo -n 'Removing all temporary binaries... '
+	@rm -f codex *.o *.core *.map *.bundle
+	@echo Done.

data/README.markdown

@@ -0,0 +1,3 @@
+Codex
+=====
+Codex is a network virtual machine. You can use it at [cloudburst.net](http://www.cloudburst.net).

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "codex"
+    gem.summary = %Q{Codex network machine}
+    gem.email = "josh@eksdyne.com"
+    gem.homepage = "http://github.com/synthemesc/codex"
+    gem.authors = ["Joshua Eckstein"]
+    # gem.rubyforge_project = "codex"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :extconf
+
+task :extconf do
+  ruby(File.join(File.dirname(__FILE__), 'extconf.rb'))
+  sh((PLATFORM =~ /win32/ ? 'nmake' : 'make') + ' -f Makefile.server')
+  sh(PLATFORM =~ /win32/ ? 'nmake' : 'make')
+
+  begin
+    require 'lib/codex'
+    File.new('VERSION', 'wb') << Codex::VERSION + "\n"
+  rescue LoadError
+  end
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "codex #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--accessor' << 'attr_xml=RW'
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/build.h

@@ -0,0 +1,11 @@
+/* Version and build number header for codex VM. */
+
+#ifndef _BUILD_H
+#define _BUILD_H
+
+#define VERSION_MAJOR	0
+#define VERSION_MINOR	0
+#define VERSION_PATCH	0
+#define CODEX_BUILD	535
+
+#endif

data/codex.c

@@ -0,0 +1,470 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <arpa/inet.h>
+#include <assert.h>
+#include <event.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+
+#include "tpl.h"
+#include "codex.h"
+#include "format.h"
+#include "vm.h"
+
+static int verbose = VERBOSITY;
+static int daemonize = FOREGROUND;
+
+#if 0
+static uint64_t CONSTANTS[] = { 0, 1 };
+#endif
+
+static struct codex sys;
+static struct event event_handle;
+static tpl_node *tpl_instructions = NULL;
+static tpl_node *tpl_registers = NULL;
+static struct sockaddr_in addr;
+static socklen_t addr_size = sizeof(addr);
+static struct instruction_word current;
+
+static void codex_message(int socket_descriptor, short event, void* args)
+{
+  static char buffer[PIPELINE_SIZE+1];
+  static int recv_length;
+
+  static uint64_t src;
+  static uint64_t arg;
+  static uint64_t result;
+
+  static uint64_t fetch_src;
+  static uint64_t fetch_arg;
+
+#define NO_FLAGS 0
+  recv_length = recvfrom(socket_descriptor, buffer, PIPELINE_SIZE,
+    NO_FLAGS, (struct sockaddr*) &addr, (socklen_t*) &addr_size);
+
+  if (UNLIKELY(recv_length < 1))
+  {
+    if (UNLIKELY(verbose)) fprintf(stderr, "Got < 1 bytes: socket error or useless.\n");
+    return;
+  }
+
+  if (UNLIKELY(tpl_load(tpl_instructions, TPL_MEM | TPL_EXCESS_OK, buffer, recv_length) == -1))
+  {
+    if (UNLIKELY(verbose)) fprintf(stderr, "Got %d bytes, but they were invalid.\n", recv_length);
+    return;
+  }
+
+  while(tpl_unpack(tpl_instructions, 1) > 0)
+  {
+    current.opcode &= VALID_INSTRUCTION;
+
+#define VALID_OFFSET(sys,off) (off>=sys.offset&&off<(sys.offset+sys.size))
+
+    /* Source decode */
+    switch(current.opcode & SRC_TYPE)
+    {
+      case SRC_TYPE_VAL:
+        fetch_src = current.src;
+        break;
+
+      case SRC_TYPE_REF:
+        if (VALID_OFFSET(sys, current.src))
+          fetch_src = sys.memory[current.src];
+        else
+          continue;
+        break;
+
+      default:
+        continue;
+    }
+
+    /* Argument decode */
+    switch(current.opcode & ARG_TYPE)
+    {
+      case ARG_TYPE_VAL:
+        fetch_arg = current.arg;
+        break;
+
+      case ARG_TYPE_REF:
+        if (VALID_OFFSET(sys, current.arg))
+          fetch_arg = sys.memory[current.arg];
+        else
+          continue;
+        break;
+
+      default:
+        continue;
+    }
+
+    /* Fetch src */
+    switch(current.opcode & SRC_MODE)
+    {
+      /* Source operand contains a hardcoded value. */
+      case SRC_MODE_IMM:   src = fetch_src; break;
+      /* Source operand contains an address. */
+      case SRC_MODE_ADDR:  src = sys.memory[fetch_src]; break;
+      /* Source operand contains a reference to a register. */
+      case SRC_MODE_REG:   src = sys.registers[fetch_src & VALID_REGISTER]; break;
+      #if 0
+      /* Source operand contains a hardcoded constant. */
+      case SRC_MODE_CONST: src = CONSTANTS[fetch_src & CONSTANT_COUNT]; break;
+      #endif
+
+      default:
+        continue;
+    }
+
+    /* Fetch argument */
+    switch(current.opcode & ARG_MODE)
+    {
+      /* Source operand contains a hardcoded value. */
+      case ARG_MODE_IMM:   arg = fetch_arg; break;
+      /* Source operand contains an address. */
+      case ARG_MODE_ADDR:  arg = sys.memory[fetch_arg]; break;
+      /* Source operand contains a reference to a register. */
+      case ARG_MODE_REG:   arg = sys.registers[fetch_arg & VALID_REGISTER]; break;
+      #if 0
+      /* Source operand contains a hardcoded constant. */
+      case ARG_MODE_CONST: arg = CONSTANTS[fetch_arg & CONSTANT_COUNT]; break;
+      #endif
+
+      default:
+        continue;
+    }
+
+    switch(current.opcode & OP_FULL)
+    {
+      /* clr %ax */
+      case OP_CLR:
+        result = 0;
+        break;
+
+      /* mov %ax, %bx */
+      case OP_MOV:
+        result = src;
+        break;
+
+      case OP_SORT:
+        if (src < arg)
+          result = -1;
+        else if (src > arg)
+          result = +1;
+        else
+          result = 0;
+
+      case OP_AVG:
+        result = (src + arg) / 2;
+
+    /*case OP_BE:*/
+    /*case OP_BNE:*/
+    /*case OP_BEZ:*/
+    /*case OP_BNEZ:*/
+    /*case OP_BLTEZ:*/
+    /*case OP_BGTEZ:*/
+    /*case OP_JMP:*/
+    /*case OP_SKP:*/
+
+      case OP_MIN:
+        if (src < arg)
+          result = src;
+        else
+          result = arg;
+        break;
+
+      case OP_MAX:
+        if (src > arg)
+          result = src;
+        else
+          result = arg;
+        break;
+
+    /*case OP_BLT:*/
+    /*case OP_BGT:*/
+    /*case OP_BLTZ:*/
+    /*case OP_BGTZ:*/
+    /*case OP_BLTE:*/
+    /*case OP_BGTE:*/
+    /*case OP_PUSH:*/
+    /*case OP_POP:*/
+
+      case OP_OR:
+        result = src | arg;
+        break;
+
+      case OP_NOR:
+        result = ~(src | arg);
+        break;
+
+      case OP_ADD:
+        result = src + arg;
+        break;
+
+      case OP_SUB:
+        result = src - arg;
+        break;
+
+      case OP_INC:
+        result = src + 1;
+        break;
+
+      case OP_DEC:
+        result = src - 1;
+        break;
+
+      case OP_GRY:
+        result = src ^ (src >> 1);
+        break;
+
+    /*case OP_HUE:*/
+    /*case OP_CALL:*/
+    /*case OP_RET:*/
+
+      case OP_AND:
+        result = src & arg;
+        break;
+
+      case OP_NAND:
+        result = ~(src & arg);
+        break;
+
+      case OP_MUL:
+        result = src * arg;
+        break;
+
+      case OP_DIV:
+        result = src / arg;
+        break;
+
+      case OP_SHL:
+        result = src << arg;
+        break;
+
+      case OP_SHR:
+        result = src >> arg;
+        break;
+
+    /*case OP_ROTL:*/
+    /*case OP_ROTR:*/
+
+      case OP_XOR:
+        result = src ^ arg;
+        break;
+
+      case OP_NOT:
+        result = ~src;
+        break;
+
+      case OP_SQR:
+        result = src * src;
+        break;
+
+      default:
+        continue;
+    }
+
+    if (UNLIKELY(verbose))
+      fprintf(stderr, "%llu <%x> %llu => %llu\n",
+        LLU current.src, current.opcode, LLU current.arg, LLU result);
+
+    switch(current.opcode & DST_TYPE)
+    {
+      case DST_MODE_ADDR:
+        if (VALID_OFFSET(sys, current.dst))
+          sys.memory[current.dst] = result;
+        else
+          continue;
+        break;
+
+      case DST_MODE_REG:
+        sys.registers[current.dst & VALID_REGISTER] = result;
+        break;
+
+      default:
+        continue;
+    }
+  }
+
+  char *reply_buffer;
+  int   reply_buffer_size;
+#define NO_FLAGS 0
+  tpl_pack(tpl_registers, 0);
+  tpl_dump(tpl_registers, TPL_MEM, &reply_buffer, &reply_buffer_size);
+  sendto(socket_descriptor, reply_buffer, reply_buffer_size,
+    NO_FLAGS, (struct sockaddr*) &addr, addr_size);
+  free(reply_buffer);
+}
+
+static void codex_shutdown()
+{
+  signal(SIGHUP,  SIG_IGN);
+  signal(SIGINT,  SIG_IGN);
+  signal(SIGQUIT, SIG_IGN);
+  signal(SIGABRT, SIG_IGN);
+
+  fprintf(stderr, "Got signal, cleaning up.. ");
+
+  if (event_initialized(&event_handle))
+  {
+    event_loopbreak();
+    fprintf(stderr, "event ");
+  }
+
+  if (sys.memory != NULL)
+  {
+    munmap(sys.memory, sys.size);
+    fprintf(stderr, "map ");
+  }
+
+  if (sys.descriptor > 0)
+  {
+    fsync(sys.descriptor); fprintf(stderr, "sync ");
+    close(sys.descriptor); fprintf(stderr, "close ");
+    fsync(sys.descriptor); fprintf(stderr, "sync ");
+  }
+
+  if (tpl_instructions != NULL)
+  {
+    tpl_free(tpl_instructions);
+    fprintf(stderr, "tpl ");
+  }
+
+  fprintf(stderr, "done.\n");
+  exit(0);
+}
+
+static void usage()
+{
+  fprintf(stderr, "codex [--daemonize] [--verbose | --silent] [--range <offset+length>] [--file <filename>] [--port <port>]\n");
+  fprintf(stderr, "codex [-d] [-v | -s] [-r <offset+length>] [-f <filename>] [-p <port>]\n");
+  exit(EXIT_FAILURE);
+}
+
+int main(int argc, char *argv[])
+{
+  signal(SIGHUP,  codex_shutdown);
+  signal(SIGINT,  codex_shutdown);
+  signal(SIGQUIT, codex_shutdown);
+  signal(SIGABRT, codex_shutdown);
+
+  static struct option long_options[] =
+  {
+    { "verbose",    no_argument, &verbose,   VERBOSE },
+    { "silent",     no_argument, &verbose,   SILENT },
+    { "daemonize",  no_argument, &daemonize, DAEMONIZE },
+    { "range",   required_argument, NULL, 'r' },
+    { "file",    required_argument, NULL, 'f' },
+    { "port",    required_argument, NULL, 'p' },
+    { 0, 0, 0, 0 }
+  };
+
+#define TO_STR(x) #x
+
+  char* range = TO_STR(DEFAULT_START+DEFAULT_SIZE);
+
+  int truth = 1;
+  uint16_t port = PORT;
+  sys.offset = DEFAULT_START;
+  sys.size   = DEFAULT_SIZE;
+
+  if (argc < 2)
+  {
+    usage();
+    return(EXIT_FAILURE);
+  }
+
+  int c;
+  while ((c = getopt_long(argc, argv, "vsdr:f:p:", long_options, NULL)) != -1)
+  {
+    switch (c)
+    {
+      case 'r':
+        range = strdup(optarg);
+        /* Allocate a range string (0x0000+0xFFFF), copy safely */
+        sys.offset = strtoll(strsep(&range, "+"), (char **)NULL, 16);
+        sys.size   = strtoll(range,               (char **)NULL, 16);
+        break;
+
+      case 'f':
+        /* Allocate a filename, copy safely */
+        strncpy(sys.filename, optarg, sizeof(sys.filename)-1);
+        sys.filename[sizeof(sys.filename)-1] = '\0';
+        break;
+
+      case 'p':
+        port = atoi(optarg);
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  if (daemonize == DAEMONIZE)
+  {
+    pid_t pid, sid;
+
+    fprintf(stderr, "Daemonizing.. ");
+    pid = fork();
+
+         if (pid < 0) exit(EXIT_FAILURE);
+    else if (pid > 0) exit(EXIT_SUCCESS);
+    umask(0);
+
+    sid = setsid();
+    if (sid < 0) exit(EXIT_FAILURE);
+    fprintf(stderr, "done.\n");
+  }
+
+  assert(port > 0);
+  assert(port < 65535);
+
+  codex_init(&sys);
+
+#define NO_PROTOCOL 0
+  int socket_descriptor;
+  assert((socket_descriptor = socket(AF_INET, SOCK_DGRAM, NO_PROTOCOL)) > 0);
+
+  fprintf(stderr, "Setting socket options.. ");
+  assert(setsockopt(socket_descriptor, SOL_SOCKET, SO_REUSEADDR, &truth, sizeof(truth)) == 0);
+  assert(setsockopt(socket_descriptor, SOL_SOCKET, SO_REUSEPORT, &truth, sizeof(truth)) == 0);
+  fprintf(stderr, "done.\n");
+
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(port);
+  addr.sin_addr.s_addr = INADDR_ANY;
+
+  fprintf(stderr, "Binding to interface on port %d.. ", port);
+  assert(bind(socket_descriptor, (struct sockaddr*) &addr, addr_size) == 0);
+  fprintf(stderr, "done.\n");
+
+  fprintf(stderr, "Constructing serializer.. ");
+  tpl_instructions = tpl_map(TPL_INSTRUCTION_FORMAT, &current);
+  tpl_registers = tpl_map(TPL_REGISTER_FORMAT, sys.registers, REGISTER_COUNT);
+  assert(tpl_instructions != NULL);
+  assert(tpl_registers != NULL);
+  fprintf(stderr, "done.\n");
+
+#define NO_CALLBACK_ARGS 0
+#define NO_TIMEOUT NULL
+#define NO_FLAGS 0
+  event_init();
+  event_set(&event_handle, socket_descriptor, EV_READ | EV_PERSIST, codex_message, NO_CALLBACK_ARGS);
+  event_add(&event_handle, NO_TIMEOUT);
+  event_loop(NO_FLAGS);
+
+  codex_shutdown();
+  return (EXIT_SUCCESS);
+}
+