flok 0.0.74 → 0.0.75

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca8fea6b0e7252ab3f9a892389bde94e80014ce4
-  data.tar.gz: 5e23aecfc89a9d7ebd4ad4f3615c0bd6bd7ac071
+  metadata.gz: 2ebb7df87c6ad3bd41410cc2feb00b57ec31ce99
+  data.tar.gz: 690eb61b2fa1857439255f483f640697792b05c8
 SHA512:
-  metadata.gz: fb6efe7e84308d32c0672d618891c7b45b0b66b33b3bd2517833cbdae5853027696042204d5bef1a23da13c945d2821923b82d792e2059391ad9b94c623dd76b
-  data.tar.gz: 346bc274195f9a5b6b8d44b52961cefe133f51b0ef1b5dbaa322ac6a0b3d41dd8dd4269d214f54fac1012acafd699fbfb07a48fd81d5cb41e498cb4046acbbfd
+  metadata.gz: 911ea2b457dad557faff40142fb337fea5d833b8d42bd5198e503b4c1850ddf38b003d5e02f78b830d6c546cec19f4548153184bd7f013244b227a0dba4e4b47
+  data.tar.gz: c77b2513cc8ee15c1f0569d402841ca09cbce328def48c2e2dc04db41f93a6fc48c37ffce6ef2fa6fbc7b699634a19892060e63494168cc35897fce45e292e98

data/app/kern/pagers/pg_dummy.js

@@ -5,6 +5,8 @@
     pg_dummy<%= i %>_ns = ns;
 
     pg_dummy<%= i %>_spec_did_init = true;
+
+    pg_dummy<%= i %>_write_vm_cache_clone = [];
   }
 
   function pg_dummy<%= i %>_watch(id, page) {
@@ -14,5 +16,8 @@
   }
 
   function pg_dummy<%= i %>_write(page) {
+    //Deep clone vm_cache at call time
+    //Used by specs looking to see if HD lookup happends
+    pg_dummy<%= i %>_write_vm_cache_clone.push(JSON.parse(JSON.stringify(vm_cache)));
   }
 <% end %>

data/app/kern/pagers/pg_sockio.js

@@ -66,7 +66,13 @@
         vm_commit(cached_page, page);
       }
 
+      //Write (Which will *not* copy the page)
       vm_cache_write(pg_sockio<%= i %>_ns, page); 
     vm_transaction_end();
+
+    //Clone page and send a copy to the server
+    var copied = vm_copy_page(page);
+    var info = {page: copied, changes: page.__changes, changes_id: page.__changes_id};
+    SEND("net", "if_sockio_send", pg_sockio<%= i %>_bp, "write", info);
   }
 <% end %>

data/app/kern/services/vm.rb

@@ -13,7 +13,15 @@ service :vm do
       <% end %>
     };
 
+    //See 'Datatypes & Structures' in ./docs/services/vm.md  
+    ////////////////////////////////////////////////////////////////////////////////////////////
     vm_bp_to_nmap = {};
+    vm_pager_waiting_read = {
+      <% @options[:pagers].each do |p| %>
+        <%= p[:namespace] %>: {},
+      <% end %>
+    };
+    vm_cache_write_sync_pending = {};
 
     //Notification listeners, converts ns+key to an array of base pointers
     vm_notify_map = {
@@ -21,8 +29,7 @@ service :vm do
         <%= p[:namespace] %>: {},
       <% end %>
     };
-
-    vm_cache_write_sync_pending = {};
+    ////////////////////////////////////////////////////////////////////////////////////////////
 
     //Cache
     function vm_cache_write(ns, page) {
@@ -115,6 +122,7 @@ service :vm do
         vm_transaction_begin();
         vm_cache_write(ns, res);
         vm_transaction_end();
+
       } else {
         //Result was blank, signal all controllers that read synchronously
         var sync_waiting_controllers = vm_cache_write_sync_pending[id];
@@ -130,6 +138,25 @@ service :vm do
         //Remove all controllers from notification list
         delete vm_cache_write_sync_pending[id];
       }
+
+      //Check if a pager is waiting for this read to complete a write request
+      var page_awaiting_write = vm_pager_waiting_read[ns][id];
+      if (page_awaiting_write !== undefined) {
+        <% @options[:pagers].each_with_index do |p, i| %>
+          <% if i == 0 %>
+            if ("<%= p[:namespace] %>" === ns) {
+              <%= p[:name] %>_write(page_awaiting_write);
+            }
+          <% else %>
+            else if ("<%= p[:namespace] %>" === ns) {
+              <%= p[:name] %>_write(page_awaiting_write);
+            }
+          <% end %>
+        <% end %>
+
+        //Clear waiting entry
+        delete vm_pager_waiting_read[ns][id];
+      }
     }
 
     <% if @debug %>
@@ -543,11 +570,26 @@ service :vm do
       vm_write_list.push(params.page);
     <% end %>
 
-    <% @options[:pagers].each do |p| %>
-      if (params.ns === "<%= p[:namespace] %>") {
-        <%= p[:name] %>_write(params.page);
+    //If the page does not exist, we need to send a disk request for a read because we may
+    //need to commit to the page
+    if (vm_cache[params.ns][params.page._id] === undefined) {
+      //Save the page into the waiting list or throw an exception if there's already a write
+      //queued, at this time, we do not support multiple writes in the same frame
+      if (vm_pager_waiting_read[params.ns][params.page._id] !== undefined) {
+        throw "vm on_write was called multiple times within the same frame (I.e. page did not exist, so we read it from disk, but that disk read didn't come back before the page was attempted to written again). This is not terribly illegal but it can lead to undefined behavior.";
       }
-    <% end %>
+      vm_pager_waiting_read[params.ns][params.page._id] = params.page;
+
+      //Notify the disk
+      SEND("disk", "if_per_get", "vm", params.ns, params.page._id);
+    } else {
+      //Else, just notify the pager right away
+      <% @options[:pagers].each do |p| %>
+        if (params.ns === "<%= p[:namespace] %>") {
+          <%= p[:name] %>_write(params.page);
+        }
+      <% end %>
+    }
   }
 
   on "watch", %{

data/docs/dispatch.md

@@ -14,7 +14,8 @@ There are various stages of message processing so it can be confusing as to what
   1. The disptach mechanism, `int_dispatch`, is always called by the client synchronously, and the javascript core will always respond synchronously to `if_disptach`. 
   2. The client `if_dispatch` handler will then process the main queue on it's same synchronous thread and then dispatch, asynchronously, the remaining queues; the queues may either each dispatch messages asynchronously or synchronously w.r.t to the original queue. (out of order and parallel are supported)
 
-Additionally, it is always ok, but not suggested, to downgrade an asynchronous request to a synchronous request.  But you can **never** downgrade a synhcronous request to an asynchronous request. Synchronous requests must be done in order and on a single thread; additionally, they can be UI requests which are typically handled on the main thread.
+Additionally, it is **never** ok to downgrade an asynchronous request to a synchronous request.  Some functions, particularly the `vm` and
+`controller` systems rely on ordering. You can also **never** downgrade a synhcronous request to an asynchronous request. Synchronous requests must be done in order and on a single thread; additionally, they can be UI requests which are typically handled on the main thread.
 
 For example, if we dispatch on the `main` queue a disk read request, flok would expect that the disk read would block the javascript core and return execution as soon as the disk read completed. Flok would also presume that the disk read was done at the fastest
 and highest priority of IO and CPU.

data/docs/known_issues.md

@@ -3,4 +3,5 @@
   0000. A `every` event used in a controller's action will time correctly on the first action, but subsequent actions will be off by at most 3 ticks.
   This is because we do not have any way (currently) to reset the timing queue in the controller as it reisters for all timing events at init. See
   "Does not call intervals of other actions; and still works when switching back actions" in `spec/kern/controller_spec.rb` 
-  0001. `Goto` macro does not recursively 'dealloc' everything.
+  0002. `vm_cache_write_sync_pending` in the `vm` service relies on page_ids, but this would cause a collision on two pages named the same thing. This
+   needs to integrate the namespace.

data/docs/services/vm.md

@@ -157,6 +157,8 @@ Pageout is embodied in the function named `vm_pageout()`. This will asynchronous
   * `vm_cache_write_sync_pending` - A hash mapping page_ids to controllers awaiting synchronous responeses, e.g.
       `vm_cache_write_sync_pending[page_id][0..N] := bp`. Usually set via the `watch` request
       during a sync call for disk reads or the synchronous `read_sync` request. The format for each element in the array is `{"page_id": [bp1, bp2], ...}`
+  * `vm_pager_waiting_read` - A hash that maps `[ns][page_id]` into a hash that represents a the page that was trying to be written.
+      needed to be read before notifying the pager. Multiple write attempts on the same page before the disk response will undefined behavior.
 
 ##Helper Methods
 

data/docs/services/vm/pagers.md

@@ -56,7 +56,11 @@ This pager provides you with local memory that will be automatically cached to d
   * `write` - Writes the given page to `vm_cache_write`
 
 ####Dummy pager | `pg_dummy0`
-This pager doesn't do anything. Used by some specs which manually write to the vm_cache in leu of the pager
+This pager doesn't do anything beyond save data during calls. Used by some specs which manually write to the vm_cache in leu of the pager
+  * `init` - Does nothing
+  * `watch` - Does nothing
+  * `unwatch` - Does nothing
+  * `write` - Pushes `vm_cache` (deep clone) into `pg_dummyN_write_vm_cache_clone` array
 
 ####Sockio pager | `pg_sockio0`
 This pager connects to a socket.io server via the `sockio` module.
@@ -73,11 +77,9 @@ This pager connects to a socket.io server via the `sockio` module.
     * `watch` - Signals to the socket.io server that a page is being watched via `watch` event with parameters `{page_id:}`
     * `unwatch` - Signals to the socket.io server that a page is no longer being watched via `unwatch` event with parameters `{page_id:}` 
     * `write` - 
-      * If the page already exists:
-        * Commits unsynced changes to `vm_cache` and notifies the server of the changes if the page already existed via `/update` with `page_id:,
-            changes:`
-      * If the page does not exist:
-        * writes directly to `vm_cache` and notifies the server of the creation via `/create` with `page:`
+       * Sends the sockio server the `write` event with a hash containing `page`, and optionally (`changes`, and `changes_id`). The `page` contains only the basic
+           page, `changes` is the vm_diff array (originally `page.__changes`) and `changes_id` was originally `page.__changes_id`. The page is a copy
+           of the original request (without __changes ([vm_diff] or __changes_id (string) in the hash if they exist)
   * **Socket.IO Event Handlers **
     * `update` - A page has been updated. This may either indicate an update or write. The page will be integrated into `vm_cache` via a rebased if it
         already exists or a direct write if it dosen't already exist. Contains one field `page:` that contains the page and a possible `changes_id`

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.74"
+  VERSION = "0.0.75"
 end

data/spec/env/kern.rb

@@ -39,11 +39,13 @@ shared_context "kern" do
     end
 
     def dump_log
+      $stderr.puts "---------------------------------------------------"
       out = self.dump "kern_log_stdout"
       self.eval "kern_log_stdout = []"
       out.each_with_index do |e, i|
         ap e
       end
+      $stderr.puts "---------------------------------------------------"
     end
   end
 

data/spec/kern/assets/vm/config5b.rb

@@ -0,0 +1,12 @@
+#Simple service config that uses built-in spec service to create a instance called 'spec'
+service_instance :vm, :vm, {
+  :pagers => [
+    {
+      :name => "pg_dummy0",
+      :namespace => "dummy",
+      :options => {
+      }
+    }
+
+  ]
+}

data/spec/kern/assets/vm/controller23.rb

@@ -0,0 +1,17 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on_entry %{
+      //Page to write
+      var page = vm_create_page("test");
+
+      //Dispatch write request
+      var info = {
+        ns: "dummy",
+        page: page
+      }
+      Request("vm", "write", info);
+    }
+  end
+end

data/spec/kern/assets/vm/controller23b.rb

@@ -0,0 +1,18 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on_entry %{
+      //Page to write
+      var page = vm_create_page("test");
+
+      //Dispatch write request
+      var info = {
+        ns: "dummy",
+        page: page
+      }
+      Request("vm", "write", info);
+      Request("vm", "write", info);
+    }
+  end
+end

data/spec/kern/assets/vm/pg_dummy/controller0.rb

@@ -0,0 +1,18 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on "do_write", %{
+      var page = vm_create_page("lol");
+
+      //Cheat and put the page in
+      vm_cache["dummy"]["lol"] = page;
+
+      var info = {
+        ns: "dummy",
+        page: page
+      }
+      Request("vm", "write", info);
+    }
+  end
+end

data/spec/kern/assets/vm/pg_sockio/write2.rb

@@ -4,7 +4,10 @@ controller :my_controller do
   on_entry %{
     read_res_params = [];
 
+    /////////////////////////////////////////////////////////////////////////
     //Create a page and commit it to the sockio cache (cheating)
+    //This way we know a commit should be performed when a write goes through
+    /////////////////////////////////////////////////////////////////////////
     var page = vm_create_page("test");
     page.entries.push(
       {"_id": "test", "_sig": "test", "val": "test"}
@@ -12,6 +15,7 @@ controller :my_controller do
     vm_reindex_page(page);
     vm_rehash_page(page);
     vm_cache["sockio"]["test"] = page;
+    /////////////////////////////////////////////////////////////////////////
   }
 
   action :my_action do

data/spec/kern/assets/vm/pg_sockio/write3.rb

@@ -0,0 +1,24 @@
+controller :my_controller do
+  services :vm
+
+  on_entry %{
+    read_res_params = [];
+  }
+
+  action :my_action do
+    on_entry %{
+      var page = vm_create_page("test");
+
+      var info = {
+        ns: "sockio",
+        page: page,
+      };
+
+      Request("vm", "write", info);
+    }
+
+    on "read_res", %{
+      read_res_params.push(JSON.parse(JSON.stringify(params)));
+    }
+  end
+end

data/spec/kern/dummy_pager_spec.rb

@@ -0,0 +1,39 @@
+#The dummy pager
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require 'zlib'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+
+RSpec.describe "kern:dummy_pager" do
+  include Zlib
+  include_context "kern"
+
+  it "Writes to the dummy pager end up in the pg_dummyN_write_vm_cache_clone array" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_dummy/controller0.rb'), File.read("./spec/kern/assets/vm/pg_dummy/config.rb") 
+    dump = ctx.evald %{
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      dump.pg_dummy0_write_vm_cache_clone = pg_dummy0_write_vm_cache_clone;
+    }
+
+    #Should be empty at first
+    expect(dump["pg_dummy0_write_vm_cache_clone"]).to eq([])
+
+    @driver.int "int_event", [
+      dump["base"],
+      "do_write",
+      {}
+    ]
+
+    #Should have gotten the write request and cloned the vm_cache
+    pg_dummy0_write_vm_cache_clone = ctx.dump "pg_dummy0_write_vm_cache_clone"
+    expect(pg_dummy0_write_vm_cache_clone.length).to eq(1)
+    expect(pg_dummy0_write_vm_cache_clone[0]["dummy"]["lol"]["_id"]).to eq("lol")
+  end
+end

data/spec/kern/vm_service_spec.rb

@@ -1390,4 +1390,129 @@ RSpec.describe "kern:vm_service" do
       "options" => {"foo" => "bar"}
     })
   end
+
+  it "Does send a disk read request when attempting to write to a page that dosen't exist in vm_cache (that page may exist on disk and will need to be commited over)" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller23.rb'), File.read("./spec/kern/assets/vm/config5b.rb") 
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #Expect a if_per_get request attempt
+    @driver.ignore_up_to "if_per_get", 2
+    @driver.mexpect "if_per_get", [
+      "vm",
+      "dummy",
+      "test"
+    ], 2
+  end
+
+  it "Does *not* send a disk read request when attempting to write to a page that dosen't exist in vm_cache (that page may exist on disk and will need to be commited over)" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller23.rb'), File.read("./spec/kern/assets/vm/config5b.rb") 
+    ctx.eval %{
+      //Fake existance of a page
+      var page = vm_create_page("test");
+      vm_rehash_page(page);
+      vm_reindex_page(page);
+      vm_cache["dummy"]["test"] = page;
+
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #Expect not to get an if_per_get request attempt (it's already cached)
+    @driver.expect_not_to_contain "if_per_get"
+  end
+
+
+  it "Does notify the pager of a write when a controller originally made a write request for a non-cached entry when that disk read returns without a page (null)" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller23.rb'), File.read("./spec/kern/assets/vm/config5b.rb") 
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #Expect a if_per_get request attempt
+    @driver.ignore_up_to "if_per_get", 2
+    @driver.mexpect "if_per_get", [
+      "vm",
+      "dummy",
+      "test"
+    ], 2
+
+    #Respond with a blank page (page does not exist on disk)
+    @driver.int "int_per_get_res", [
+      "vm",
+      "dummy",
+      "test",
+      nil
+    ]
+
+    #Expect the pager to have received a write request by now
+    dump = ctx.evald %{
+      dump.pg_dummy0_write_vm_cache_clone = pg_dummy0_write_vm_cache_clone 
+    }
+
+    expect(dump["pg_dummy0_write_vm_cache_clone"]).to eq([
+      {"dummy" => {}}
+    ])
+  end
+
+  it "Does notify the pager of a write when a controller originally made a write request for a non-cached entry when that disk read returns with a page" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller23.rb'), File.read("./spec/kern/assets/vm/config5b.rb") 
+    ctx.eval %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    #Expect a if_per_get request attempt
+    @driver.ignore_up_to "if_per_get", 2
+    @driver.mexpect "if_per_get", [
+      "vm",
+      "dummy",
+      "test"
+    ], 2
+
+    #Respond with a blank page (page does not exist on disk)
+    @driver.int "int_per_get_res", [
+      "vm",
+      "dummy",
+      "test",
+      {
+        "_id" => "test",
+        "_next" => nil,
+        "_head" => nil,
+        "entries" => []
+      }
+    ]
+
+    #Expect the pager to have received a write request by now, and the dummy pager saves everything
+    #it gets into a special variable queue (copied via deep clone of vm_cache)
+    dump = ctx.evald %{
+      dump.pg_dummy0_write_vm_cache_clone = pg_dummy0_write_vm_cache_clone 
+    }
+    expect(dump["pg_dummy0_write_vm_cache_clone"].length).to eq(1)
+    expect(dump["pg_dummy0_write_vm_cache_clone"][0]["dummy"]["test"]).not_to eq(nil)
+    expect(dump["pg_dummy0_write_vm_cache_clone"][0]["dummy"]["test"]["_id"]).to eq("test")
+  end
+
+  it "Does throw an exception if two writes are attempted in the same frame for a non-cached page" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/controller23b.rb'), File.read("./spec/kern/assets/vm/config5b.rb") 
+    expect {
+      ctx.eval %{
+        base = _embed("my_controller", 0, {}, null);
+
+        //Drain queue
+        int_dispatch([]);
+      }
+    }.to raise_error(/.*multiple.*/)
+  end
 end

data/spec/kern/vm_sockio_pager_spec.rb

@@ -452,7 +452,7 @@ RSpec.describe "kern:sockio_pager" do
     ])
   end
 
-  it "Does accept writes of pages that don't currently exist in cache; they go into vm_cache as-is" do
+  it "Does accept writes of pages that don't currently exist in cache; they go into vm_cache as-is and are sent to the sockio driver" do
     ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/write.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
     dump = ctx.evald %{
       //Call embed on main root view
@@ -464,8 +464,22 @@ RSpec.describe "kern:sockio_pager" do
       dump.vm_cache = vm_cache;
     }
 
+    #Driver response
+    @driver.int "int_per_get_res", [
+      "vm",
+      "sockio",
+      "test"
+    ], 2
+
     #The vm_cache should now contain an entry for the page
     expect(dump["vm_cache"]["sockio"]["test"]).not_to eq(nil)
+
+    @driver.ignore_up_to "if_sockio_send", 1
+    @driver.mexpect "if_sockio_send", [
+      Integer,
+      "page_write",
+       dump["vm_cache"]["sockio"]["test"] 
+    ], 1
   end
 
   it "Does accept writes of pages that **do** currently exist in cache; they go into vm_cache commited" do
@@ -487,4 +501,52 @@ RSpec.describe "kern:sockio_pager" do
     expect(dump["vm_cache"]["sockio"]["test"]["__changes"]).not_to eq(nil)
     expect(dump["vm_cache"]["sockio"]["test"]["__changes_id"]).not_to eq(nil)
   end
+
+  it "Does write to sockio interface when a page is requested to be written with changes with a page and changes" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/write2.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
+    dump = ctx.evald %{
+      //Call embed on main root view
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      dump.vm_cache = vm_cache;
+    }
+
+    #The kernel should have signaled to the driver to send a sockio request with the changes
+    @driver.ignore_up_to "if_sockio_send", 1
+    res = @driver.get "if_sockio_send", 1
+    expect(res[2]["page"]["_id"]).to eq("test")
+    expect(res[2]["changes"]).to eq([["-", "test"]])
+    expect(res[2]["changes_id"].class).to eq(String)
+  end
+
+  it "Does write to sockio interface when a page is requested to be written without changes with a page: and no changes: field" do
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/pg_sockio/write3.rb'), File.read("./spec/kern/assets/vm/pg_sockio/config.rb") 
+    dump = ctx.evald %{
+      //Call embed on main root view
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      dump.vm_cache = vm_cache;
+    }
+
+    #The HD should have been requested (as it's not cached and it tries to lookup)
+    @driver.int "int_per_get_res", [
+      "vm",
+      "sockio",
+      "test",
+      nil
+    ]
+
+    #The kernel should have signaled to the driver to send a sockio request without the changes
+    @driver.ignore_up_to "if_sockio_send", 1
+    res = @driver.get "if_sockio_send", 1
+    expect(res[2]["page"]["_id"]).to eq("test")
+    expect(res[2]["changes"]).to eq(nil)
+    expect(res[2]["changes_id"]).to eq(nil)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flok
 version: !ruby/object:Gem::Version
-  version: 0.0.74
+  version: 0.0.75
 platform: ruby
 authors:
 - seo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-27 00:00:00.000000000 Z
+date: 2015-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: execjs
@@ -1208,6 +1208,7 @@ files:
 - spec/kern/assets/vm/config3.rb
 - spec/kern/assets/vm/config4.rb
 - spec/kern/assets/vm/config5.rb
+- spec/kern/assets/vm/config5b.rb
 - spec/kern/assets/vm/config6.rb
 - spec/kern/assets/vm/controller0.rb
 - spec/kern/assets/vm/controller0_diff.rb
@@ -1234,6 +1235,8 @@ files:
 - spec/kern/assets/vm/controller20.rb
 - spec/kern/assets/vm/controller21.rb
 - spec/kern/assets/vm/controller22.rb
+- spec/kern/assets/vm/controller23.rb
+- spec/kern/assets/vm/controller23b.rb
 - spec/kern/assets/vm/controller3.rb
 - spec/kern/assets/vm/controller4.rb
 - spec/kern/assets/vm/controller5.rb
@@ -1263,6 +1266,7 @@ files:
 - spec/kern/assets/vm/macros/set_page_head_c.rb
 - spec/kern/assets/vm/macros/set_page_next_c.rb
 - spec/kern/assets/vm/pg_dummy/config.rb
+- spec/kern/assets/vm/pg_dummy/controller0.rb
 - spec/kern/assets/vm/pg_mem/config.rb
 - spec/kern/assets/vm/pg_mem/config1.rb
 - spec/kern/assets/vm/pg_mem/config2.rb
@@ -1280,6 +1284,7 @@ files:
 - spec/kern/assets/vm/pg_sockio/watch2.rb
 - spec/kern/assets/vm/pg_sockio/write.rb
 - spec/kern/assets/vm/pg_sockio/write2.rb
+- spec/kern/assets/vm/pg_sockio/write3.rb
 - spec/kern/assets/vm/service0.rb
 - spec/kern/assets/vm/service_controller0.rb
 - spec/kern/assets/vm/vm_commit_pages.js
@@ -1291,6 +1296,7 @@ files:
 - spec/kern/debug_spec.rb
 - spec/kern/debug_ui_spec.rb
 - spec/kern/dispatch_spec.rb
+- spec/kern/dummy_pager_spec.rb
 - spec/kern/event_spec.rb
 - spec/kern/functions_spec.rb
 - spec/kern/global_functions_spec.rb
@@ -2151,6 +2157,7 @@ test_files:
 - spec/kern/assets/vm/config3.rb
 - spec/kern/assets/vm/config4.rb
 - spec/kern/assets/vm/config5.rb
+- spec/kern/assets/vm/config5b.rb
 - spec/kern/assets/vm/config6.rb
 - spec/kern/assets/vm/controller0.rb
 - spec/kern/assets/vm/controller0_diff.rb
@@ -2177,6 +2184,8 @@ test_files:
 - spec/kern/assets/vm/controller20.rb
 - spec/kern/assets/vm/controller21.rb
 - spec/kern/assets/vm/controller22.rb
+- spec/kern/assets/vm/controller23.rb
+- spec/kern/assets/vm/controller23b.rb
 - spec/kern/assets/vm/controller3.rb
 - spec/kern/assets/vm/controller4.rb
 - spec/kern/assets/vm/controller5.rb
@@ -2206,6 +2215,7 @@ test_files:
 - spec/kern/assets/vm/macros/set_page_head_c.rb
 - spec/kern/assets/vm/macros/set_page_next_c.rb
 - spec/kern/assets/vm/pg_dummy/config.rb
+- spec/kern/assets/vm/pg_dummy/controller0.rb
 - spec/kern/assets/vm/pg_mem/config.rb
 - spec/kern/assets/vm/pg_mem/config1.rb
 - spec/kern/assets/vm/pg_mem/config2.rb
@@ -2223,6 +2233,7 @@ test_files:
 - spec/kern/assets/vm/pg_sockio/watch2.rb
 - spec/kern/assets/vm/pg_sockio/write.rb
 - spec/kern/assets/vm/pg_sockio/write2.rb
+- spec/kern/assets/vm/pg_sockio/write3.rb
 - spec/kern/assets/vm/service0.rb
 - spec/kern/assets/vm/service_controller0.rb
 - spec/kern/assets/vm/vm_commit_pages.js
@@ -2234,6 +2245,7 @@ test_files:
 - spec/kern/debug_spec.rb
 - spec/kern/debug_ui_spec.rb
 - spec/kern/dispatch_spec.rb
+- spec/kern/dummy_pager_spec.rb
 - spec/kern/event_spec.rb
 - spec/kern/functions_spec.rb
 - spec/kern/global_functions_spec.rb