componolit / gravel Goto Github PK

See Componolit/gneiss#128.

Extend the Socat component to also provide a stream interface

When running the block correctness test on Genode I run into a segmentation fault (on base-linux) in the ringbuffer that doesn't use any platform interfaces. After som investigation I noticed that

R.Data  := (others => (Block.Id'Last, False, Null_Buffer));

caused the segmentation fault. All inputs come from pure Ada and do not have any platform interaction. Also no C++ runtime or interface code was called in this statement.

Changing this statement to

for I in R.Data'Range loop                                                                                        
   R.Data (I).Block_Id := Block.Id'Last;                                                                          
   R.Data (I).Set      := False;                                                                                  
   R.Data (I).Data     := Null_Buffer;                                                                            
end loop;

solved the issue. I suspect that some compiler generated code is used that either the runtime or the interface library are not configured for. On Linux the same code works without issues. We should check where we might have to enforce static initialization or forbid those statements (at least for larger loops). A pragma Restrictions (No_Implicit_Loops) might prevent such constructs although some constants might not be able to be initialized anymore.

Implement a block client that measures the good-case throughput of a block server. A test works as follows:

• For request type (in read/write):

  • For request size (between device block size .. 2 MB (?)):
    • For number of requests:
      • Send request of request type
    • Wait for all request to finish
    • Calculate throughput

• For all events handling a response or request:

  • Record queue size (requests in flight) and time stamp

Requests are performed linearly in ascending order.

Update Gravel to Gneiss 0.2. This includes:

• Using cement build system on Linux
• Renaming libs to lib to be consistent with Gneiss
• Removing libraries from lib that are already provided by Gneiss

As a real world use case for the Gneiss we should build a partition manager for GPT partitions. This is a showcase to see if our interface can cope with real world work loads. It also addresses the issue on how labels should be handled in regard to how a server can route incoming requests.

Requests are split into blocks. For every write request, blocks are put into the cache and written to the backend device. Every read request, is looked up in the cache. For a miss, the block is read from the backend device and put into the cache. For a hit, the request is serviced from the cache.

Cache entries are evicted on a LRU basis.