evoasm 0.0.2.pre7 → 0.1.0.pre2

data/docs/examples/jit.rb

@@ -0,0 +1,26 @@
+require 'evoasm'
+require 'evoasm/x64'
+
+buffer = Evoasm::Buffer.new 1024
+Evoasm::X64.emit_stack_frame buffer do
+  Evoasm::X64.encode(:mov_rm32_imm32, {reg0: :a, imm0: 1}, buffer)
+  Evoasm::X64.encode(:mov_rm32_imm32, {reg0: :b, imm0: 2}, buffer)
+  Evoasm::X64.encode(:add_r32_rm32, {reg0: :a, reg1: :b}, buffer)
+end
+
+puts "Result: #{buffer.execute!}"
+
+buffer.reset
+
+Evoasm::X64.emit_stack_frame buffer do
+  Evoasm::X64.encode(:mov_rm32_imm32, {reg0: :b, imm0: 0}, buffer)
+  Evoasm::X64.encode(:mov_rm32_imm32, {reg0: :a, imm0: 100}, buffer)
+  Evoasm::X64.encode(:div_rm64, {reg0: :b}, buffer)
+end
+
+begin
+  buffer.execute!
+rescue Evoasm::ExceptionError => e
+  puts "Execution failed with exception `#{e.exception_name}'"
+end
+

data/docs/examples/sym_reg.rb

@@ -0,0 +1,64 @@
+require 'evoasm'
+require 'evoasm/x64'
+
+Evoasm.log_level = :warn
+
+examples = {
+  0.0 => 0.0,
+  0.5 => 1.0606601717798212,
+  1.0 => 1.7320508075688772,
+  1.5 => 2.5248762345905194,
+  2.0 => 3.4641016151377544,
+  2.5 => 4.541475531146237,
+  3.0 => 5.744562646538029,
+  3.5 => 7.0622234459127675,
+  4.0 => 8.48528137423857,
+  4.5 => 10.00624804809475,
+  5.0 => 11.61895003862225
+}
+
+parameters = Evoasm::Population::Parameters.new do |p|
+  p.instructions = Evoasm::X64.instruction_names(:xmm).grep /(add|mul|sqrt).*?sd/
+  p.examples = examples
+  p.deme_size = 1024
+  p.deme_count = 1
+  p.kernel_size = 10
+  p.program_size = 1
+  p.parameters = %i(reg0 reg1 reg2 reg3)
+
+  regs = %i(xmm0 xmm1 xmm2 xmm3)
+
+  p.domains = {
+    reg0: regs,
+    reg1: regs,
+    reg2: regs,
+    reg3: regs
+  }
+end
+
+puts "Supported features:"
+Evoasm::X64.features.each do |feature, supported|
+  puts "\t#{feature.to_s.upcase}: #{supported ? 'YES' : 'NO'}"
+end
+puts
+
+population = Evoasm::Population.new parameters
+program, loss = population.run
+
+puts program.disassemble format: true
+
+puts
+
+puts program.run 6.0
+puts program.run 7.0
+
+puts
+
+program = program.eliminate_introns
+puts program.disassemble format: true
+
+puts
+
+puts program.run 6.0
+puts program.run 7.0
+

data/docs/examples/vis.rb

@@ -0,0 +1,38 @@
+require 'evoasm'
+require 'evoasm/x64'
+
+Evoasm.log_level = :warn
+
+examples = {
+  [5, 1] => 1,
+  [15, 5] => 5,
+  [8, 2] => 2,
+  [8, 4] => 4,
+  [8, 6] => 2,
+  [16, 8] => 8,
+  [16, 2] => 2,
+  [100, 10] => 10,
+  [60, 10] => 10
+}
+
+parameters = Evoasm::Population::Parameters.new do |p|
+  p.instructions = Evoasm::X64.instruction_names(:gp, :rflags)
+  p.examples = examples
+  p.deme_size = 2048
+  p.parameters = %i(reg0 reg1 reg2 reg3)
+  p.kernel_size = 20
+  p.program_size = 3
+  p.mutation_rate = 0.03
+  p.deme_count = 2
+  p.recur_limit = 100
+end
+
+population = Evoasm::Population.new parameters
+program, loss = population.run do
+  p "gen"
+  population.plot File.join(__dir__, 'loss.gif')
+end
+
+p loss
+
+program.to_gv.save File.join(__dir__, 'program.png')

data/evoasm.gemspec

@@ -4,27 +4,33 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'evoasm/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "evoasm"
+  spec.name          = 'evoasm'
   spec.version       = Evoasm::VERSION
-  spec.authors       = ["Julian Aron Prenner (furunkel)"]
-  spec.email         = ["furunkel@polyadic.com"]
-  spec.summary       = %q{An AIMGP (Automatic Induction of Machine code by Genetic Programming) engine}
-  spec.homepage      = "https://github.com/furunkel/evoasm/"
-  spec.license       = "MPL-2.0"
+  spec.authors       = ['Julian Aron Prenner (furunkel)']
+  spec.email         = ['furunkel@polyadic.com']
+  spec.summary       = %q{An AIMGP engine}
+  spec.description   = %q{An AIMGP (Automatic Induction of Machine code by Genetic Programming) engine}
+  spec.homepage      = 'https://github.com/evoasm/evoasm/'
+  spec.license       = 'AGPL-3.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
+  spec.files        += Dir['ext/evoasm_ext/**/*.[ch]']
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-  spec.extensions    = spec.files.grep(%r{extconf.rb})
+  spec.require_paths = ['lib']
+  spec.extensions    = %w(ext/evoasm_ext/Rakefile)
 
-  spec.add_dependency "pry", "~> 0.10"
-  spec.add_dependency "pastel", "~> 0.6"
+  spec.add_dependency 'pastel', '~> 0.6'
+  spec.add_dependency 'ffi', '~> 1.9'
+  spec.add_dependency 'gv', '~> 0.1'
+  spec.add_dependency 'haml', '~> 4.0'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rake-compiler", "~> 0.9"
-  spec.add_development_dependency 'erubis', '~> 2.6'
-  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rubocop', '~> 0.41'
+  spec.add_development_dependency 'minitest', '~> 5.8'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'redcarpet', '~> 3.3'
+  spec.add_development_dependency 'yard', '~> 0.9'
 end

data/ext/evoasm_ext/Rakefile

@@ -0,0 +1,3 @@
+import 'compile.rake'
+
+task :default => :compile

data/ext/evoasm_ext/compile.rake

@@ -0,0 +1,35 @@
+require 'rake/clean'
+require 'ffi'
+
+SHARED_LIB = File.join(__dir__, FFI.map_library_name('evoasm'))
+SRC_FILES = FileList[File.join __dir__, 'libevoasm/src/**/*.[ch]']
+C_FILES = SRC_FILES.clone.exclude(/\.h$/).join(' ')
+CC = ENV['cc'] || 'cc'
+INC_FLAGS = %w(libevoasm/src).map { |dir| "-I#{File.join __dir__, dir}"}.join ' '
+
+DEFS = ''
+CFLAGS = ''
+
+if ARGV.include?('--debug')
+  DEFS << ' -DEVOASM_LOG_LEVEL=EVOASM_LOG_LEVEL_DEBUG'
+  CFLAGS << ' -ggdb3 -O0'
+else
+  DEFS << ' -DNDEBUG'
+  CFLAGS << ' -O3 -march=native'
+end
+
+if ARGV.include?('--paranoid')
+  DEFS << ' -DEVOASM_ENABLE_PARANOID_MODE'
+end
+
+unless ARGV.include?('--no-omp')
+  CFLAGS << ' -fopenmp'
+end
+
+CLEAN.include(SHARED_LIB)
+
+desc "Compile shared library"
+task :compile => [SHARED_LIB]
+file SHARED_LIB => SRC_FILES do |t|
+  sh "#{CC} -shared -fPIC #{CFLAGS} #{DEFS} #{C_FILES} #{INC_FLAGS} -o #{SHARED_LIB}"
+end

data/ext/evoasm_ext/libevoasm/src/evoasm-alloc.c

@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2016 Julian Aron Prenner <jap@polyadic.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "evoasm-alloc.h"
+#include "evoasm.h"
+
+#include <stdlib.h>
+#include <errno.h>
+
+EVOASM_DEF_LOG_TAG("alloc")
+
+void *
+evoasm_malloc(size_t size) {
+  void *ptr = malloc(size);
+  if(evoasm_unlikely(!ptr)) {
+    evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+                 "Allocating %zu bytes via malloc failed: %s", size, strerror(errno));
+    return NULL;
+  }
+  return ptr;
+}
+
+void *
+evoasm_aligned_alloc(size_t align, size_t size) {
+  void *ptr = aligned_alloc(align, size);
+  if(evoasm_unlikely(!ptr)) {
+    evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+                 "Allocating %zu bytes via aligned_alloc failed: %s", size, strerror(errno));
+    return NULL;
+  }
+  return ptr;
+}
+
+void *
+evoasm_calloc(size_t n, size_t size) {
+  void *ptr = calloc(n, size);
+
+  if(evoasm_unlikely(!ptr)) {
+    evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+                 "Allocating %zux%zu (%zu) bytes via calloc failed: %s", n, size, n * size, strerror(errno));
+    return NULL;
+  }
+  return ptr;
+}
+
+void *
+evoasm_aligned_calloc(size_t align, size_t n, size_t size) {
+  if(evoasm_unlikely(size == 0 || n >= SIZE_MAX / size)) {
+    evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+                 "Allocating %zux%zu bytes via aligned_calloc failed: integer overflow", n, size);
+    return NULL;
+  }
+
+  size_t len = n * size;
+  void *ptr = evoasm_aligned_alloc(align, len);
+
+  if(evoasm_likely(ptr != NULL)) {
+    memset(ptr, 0, len);
+  }
+  return ptr;
+}
+
+void *
+evoasm_realloc(void *ptr, size_t size) {
+  void *new_ptr = realloc(ptr, size);
+
+  if(evoasm_unlikely(!ptr)) {
+    evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+                 "Allocating %zu bytes via realloc failed: %s", size, strerror(errno));
+    return NULL;
+  }
+  return new_ptr;
+}
+
+void
+evoasm_free(void *ptr) {
+  free(ptr);
+}
+
+void *
+evoasm_mmap(size_t size, void *p) {
+  /* Note that mmap considers the pointer passed soley as a hint address
+   * and returns a valid address (possibly at a different address) in any case.
+   * VirtualAlloc, on the other hand, will return NULL if the address is
+   * not available
+   */
+  void *mem;
+
+#if defined(_WIN32)
+  retry:
+      mem = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE);
+      if(mem == NULL) {
+        if(p != NULL) {
+          goto retry;
+        } else {
+          goto error;
+        }
+      }
+      return mem;
+#elif defined(_POSIX_VERSION)
+  mem = mmap(p, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  if(mem == MAP_FAILED) {
+    goto error;
+  }
+#else
+#error
+#endif
+  return mem;
+
+error:
+  evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+               "Allocating %zu bytes via mmap failed: %s", size, strerror(errno));
+  return NULL;
+}
+
+evoasm_success_t
+evoasm_munmap(void *p, size_t size) {
+  bool ret;
+#if defined(_WIN32)
+  ret = VirtualFree(p, size, MEM_DECOMMIT);
+#elif defined(_POSIX_VERSION)
+  ret = (munmap(p, size) == 0);
+#else
+#  error
+#endif
+
+  if(!ret) {
+    evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+                 "Unmapping %zu bytes via munmap failed: %s", size, strerror(errno));
+  }
+
+  return ret;
+}
+
+
+#if defined(_WIN32)
+#define EVOASM_MPROT_RW PAGE_READWRITE
+#define EVOASM_MPROT_RX PAGE_EXECUTE_READ
+#define EVOASM_MPROT_RWX PAGE_EXECUTE_READWRITE
+#elif defined(_POSIX_VERSION)
+#define EVOASM_MPROT_RW (PROT_READ|PROT_WRITE)
+#define EVOASM_MPROT_RX (PROT_READ|PROT_EXEC)
+#define EVOASM_MPROT_RWX (PROT_READ|PROT_WRITE|PROT_EXEC)
+#else
+#error
+#endif
+
+evoasm_success_t
+evoasm_mprot(void *p, size_t size, evoasm_mprot_mode_t mode) {
+  int mode_;
+
+  switch(mode) {
+    case EVOASM_MPROT_MODE_RW:
+      mode_ = EVOASM_MPROT_RW;
+      break;
+    case EVOASM_MPROT_MODE_RWX:
+      mode_ = EVOASM_MPROT_RWX;
+      break;
+    case EVOASM_MPROT_MODE_RX:
+      mode_ = EVOASM_MPROT_RX;
+      break;
+    default:
+      evoasm_assert_not_reached();
+  }
+
+
+#if defined(_WIN32)
+  if(VirtualProtect(p, size, mode_, NULL) != 0) {
+    goto error;
+  }
+#elif defined(_POSIX_VERSION)
+  if(mprotect(p, size, mode_) != 0) {
+    goto error;
+  }
+#else
+#error
+#endif
+  return true;
+
+error:
+  evoasm_error(EVOASM_ERROR_TYPE_ALLOC, EVOASM_ERROR_CODE_NONE,
+               "Changing memory protection failed: %s", strerror(errno));
+  return false;
+}
+
+static size_t _evoasm_page_size = 0;
+
+static long
+evoasm_query_page_size() {
+#if defined(_WIN32)
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+#elif defined(_POSIX_VERSION)
+  return sysconf(_SC_PAGESIZE);
+#else
+#error
+#endif
+}
+
+size_t
+evoasm_get_page_size() {
+  if(_evoasm_page_size == 0) {
+    long page_size = evoasm_query_page_size();
+    if(page_size == -1) {
+      page_size = 4096;
+      evoasm_log_warn("requesting page size failed. This might cause problems.");
+    }
+    _evoasm_page_size = (size_t) page_size;
+  }
+  return (size_t) _evoasm_page_size;
+}