Port over changes made for paper submission

applications/flatware/examples/open/open-deep.c

@@ -41,7 +41,7 @@ int main()
 
   printf( "fd_3 = %d\n", fd_3 );
 
-  if ( fd_3 >= 0 ) {
+  if ( fd_3 < 0 ) {
     return -1;
   }
 

applications/flatware/examples/python/CMakeLists.txt

@@ -1,13 +1,19 @@
 file(
   DOWNLOAD
-  https://github.com/vmware-labs/webassembly-language-runtimes/releases/download/python%2F3.12.0%2B20231211-040d5a6/python-3.12.0.wasm
-  ${CMAKE_CURRENT_BINARY_DIR}/python.wasm
+  https://github.com/vmware-labs/webassembly-language-runtimes/releases/download/python%2F3.12.0%2B20231211-040d5a6/python-3.12.0-wasi-sdk-20.0.tar.gz
+  ${CMAKE_CURRENT_BINARY_DIR}/python.tar.gz
   SHOW_PROGRESS
 )
 
+file(
+  ARCHIVE_EXTRACT
+  INPUT ${CMAKE_CURRENT_BINARY_DIR}/python.tar.gz
+  DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/python-workingdir
+)
+
 add_custom_command(
   OUTPUT "python-fixpoint.wasm"
-  DEPENDS python.wasm
+  DEPENDS python-workingdir/bin/python-3.12.0.wasm
           ../../c-flatware.c
           ../../filesys.c
           ../../asm-flatware.wat
@@ -16,7 +22,7 @@ add_custom_command(
   COMMAND $ENV{HOME}/wasm-toolchain/wasm-tools/build/src/module-combiner/wasmlink
           --enable-multi-memory
           --enable-exceptions
-          python.wasm
+          python-workingdir/bin/python-3.12.0.wasm
           ../../wasi_snapshot_preview1.wasm
           -m wasi_command
           -n wasi_snapshot_preview1

etc/tests.cmake

@@ -14,7 +14,7 @@ add_custom_target (all-local-fixpoint-check COMMAND ${CMAKE_CTEST_COMMAND} --out
   COMMENT "Testing Fix..."
 )
 
-add_custom_target (flatware-check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -R "^f_" -E "f_python_flatware" -E "f_build_python"
+add_custom_target (flatware-check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -R "^f_" -E "f_python_flatware"
   COMMENT "Testing Flatware..."
 )
 add_custom_target (all-flatware-check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -R "^f_" COMMENT "Testing Flatware...")
@@ -59,7 +59,7 @@ add_test(NAME f_return_flatware WORKING_DIRECTORY COMMAND ${CMAKE_CURRENT_BINARY
 add_test(NAME f_helloworld_flatware WORKING_DIRECTORY COMMAND ${CMAKE_CURRENT_BINARY_DIR}/src/tests/test-helloworld-flatware)
 add_test(NAME f_open_flatware WORKING_DIRECTORY COMMAND ${CMAKE_CURRENT_BINARY_DIR}/src/tests/test-open-flatware)
 
-add_test(NAME f_build_python WORKING_DIRECTORY COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}/applications-prefix/src/applications-build/ --target python_fixpoint --parallel)
+add_test(NAME s_build_python WORKING_DIRECTORY COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}/applications-prefix/src/applications-build/ --target python_fixpoint --parallel)
 add_test(NAME f_python_flatware WORKING_DIRECTORY COMMAND ${CMAKE_CURRENT_BINARY_DIR}/src/tests/test-python-flatware)
-set_tests_properties(f_build_python PROPERTIES FIXTURES_SETUP python_fixture)
+set_tests_properties(s_build_python PROPERTIES FIXTURES_SETUP python_fixture)
 set_tests_properties(f_python_flatware PROPERTIES FIXTURES_REQUIRED python_fixture)

src/handle/blob.hh

@@ -117,6 +117,10 @@ public:
     content[30] |= ( 1 << 7 );
   }
 
+  Handle()
+    : Handle( 0, 64 )
+  {}
+
   inline u8x32 hash() const
   {
     u64x4 hash = (u64x4)content;

src/runtime/dependency_graph.hh

@@ -73,8 +73,7 @@ public:
     if ( backward_dependencies_.contains( task_or_object ) ) {
       for ( const auto dependent : backward_dependencies_[task_or_object] ) {
         auto& target = forward_dependencies_[dependent];
-        target.erase( task_or_object );
-        if ( target.empty() ) {
+        if ( target.erase( task_or_object ) && target.empty() ) {
           VLOG( 2 ) << "resuming " << dependent;
           unblocked.insert( dependent );
           forward_dependencies_.erase( dependent );

src/runtime/executor.cc

@@ -2,10 +2,12 @@
 #include <memory>
 #include <optional>
 #include <string_view>
+#include <unistd.h>
 #include <vector>
 
 #include "executor.hh"
 #include "fixpointapi.hh"
+#include "handle.hh"
 #include "overload.hh"
 #include "resource_limits.hh"
 #include "storage_exception.hh"
@@ -21,6 +23,7 @@ Executor::Executor( Relater& parent, size_t threads, optional<shared_ptr<Runner>
                                 : make_shared<WasmRunner>( parent.labeled( "compile-elf" ),
                                                            parent.labeled( "compile-fixed-point" ) ) )
 {
+  fixpoint::storage = &parent_.storage_;
   for ( size_t i = 0; i < threads; i++ ) {
     threads_.emplace_back( [&]() {
       fixpoint::storage = &parent_.storage_;
@@ -91,7 +94,39 @@ Result<Object> Executor::apply( Handle<ObjectTree> combination )
   VLOG( 2 ) << "Apply " << combination;
 
   TreeData tree = parent_.storage_.get( combination );
+  auto rlimits = tree->at( 0 );
+
+  VLOG( 2 ) << combination << " rlimits are " << rlimits;
+  auto limits = rlimits.unwrap<Expression>()
+                  .unwrap<Object>()
+                  .try_into<Value>()
+                  .and_then( [&]( auto x ) { return x.template try_into<ValueTree>(); } )
+                  .transform( [&]( auto x ) { return fixpoint::storage->get( x ); } );
+
+  auto requested
+    = limits
+        .and_then( [&]( auto x ) {
+          return handle::extract<Literal>(
+            x->at( 0 ).template unwrap<Expression>().template unwrap<Object>().template unwrap<Value>() );
+        } )
+        .transform( [&]( auto x ) { return uint64_t( x ); } )
+        .value_or( 0 );
+
+  {
+    auto w = parent_.available_memory_.write();
+    Handle<Relation> apply
+      = Handle<Think>( Handle<Thunk>( Handle<Application>( Handle<ExpressionTree>( combination ) ) ) );
+    VLOG( 2 ) << "Occupying " << apply << " " << w.get() << " " << requested;
+    if ( w.get() < requested ) {
+      VLOG( 1 ) << "Out of memory " << w.get() << " " << requested;
+      return {};
+    }
+
+    w.get() -= requested;
+  }
+
   auto result = runner_->apply( combination, tree );
+  parent_.available_memory_.write().get() += requested;
 
   return result;
 }
@@ -117,6 +152,17 @@ std::optional<Handle<Object>> Executor::get( Handle<Relation> name )
   return {};
 }
 
+void Executor::retry( Handle<Relation> name )
+{
+  if ( threads_.size() == 0 ) {
+    throw HandleNotFound( name );
+  }
+
+  auto graph = parent_.graph_.write();
+  graph->start( name );
+  todo_.push( name );
+}
+
 std::optional<Handle<AnyTree>> Executor::get_handle( Handle<AnyTree> )
 {
   return {};

src/runtime/executor.hh

@@ -42,6 +42,7 @@ public:
   virtual std::optional<BlobData> get( Handle<Named> name ) override;
   virtual std::optional<TreeData> get( Handle<AnyTree> name ) override;
   virtual std::optional<Handle<Object>> get( Handle<Relation> name ) override;
+  void retry( Handle<Relation> name );
   virtual std::optional<Handle<AnyTree>> get_handle( Handle<AnyTree> name ) override;
   virtual std::optional<TreeData> get_shallow( Handle<AnyTree> name ) override;
   virtual void put( Handle<Named> name, BlobData data ) override;