ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-04-07 19:34:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

base: transition to new API for tests (ref #1987)

Browse Source
This commit is contained in:
Stefan Kalkowski 2017-01-05 16:19:16 +01:00 committed by Norman Feske
parent d07cd0e88e
commit aa004cf211
12 changed files with 170 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
repos/base/run/new_delete.run
View File

@ -21,7 +21,7 @@ build_boot_image "core ld.lib.so init test-new_delete"
append qemu_args "-nographic -m 64"
run_genode_until {child "test-new_delete" exited with exit value 0.*\n} 15
run_genode_until "Test done.*\n" 15
grep_output {^\[init -> test-new_delete\]}

2
repos/base/run/rm_nested.run
View File

@ -28,4 +28,4 @@ build_boot_image "core ld.lib.so init test-rm_nested"
append qemu_args "-nographic -m 64"
run_genode_until {child "test-rm_nested" exited with exit value 0.*} 300
run_genode_until ".*--- finished nested region map test ---.*\n" 300

2
repos/base/run/slab.run
View File

@ -32,6 +32,6 @@ build_boot_image "core ld.lib.so init timer test-slab"
append qemu_args "-nographic -m 128"
run_genode_until {child "test-slab" exited with exit value 0.*\n} 100
run_genode_until "Test done.*\n" 100
puts "Test succeeded"

116
repos/base/src/test/fpu/main.cc
View File

@ -12,39 +12,20 @@
*/
/* Genode includes */
#include <base/thread.h>
#include <base/sleep.h>
#include <base/component.h>
#include <base/heap.h>
#include <base/log.h>
#include <base/thread.h>
using namespace Genode;
class Sync_signal_transmitter : public Signal_transmitter
class Fpu_user : public Thread
{
private:
Lock _lock;
public:
Sync_signal_transmitter(Signal_context_capability context = Signal_context_capability())
:
Signal_transmitter(context),
_lock(Lock::UNLOCKED)
{ }
void submit(unsigned cnt)
{
Lock::Guard guard(_lock);
Signal_transmitter::submit(cnt);
}
};
class Fpu_user : public Thread_deprecated<0x2000>
{
private:
float _x;
Sync_signal_transmitter * _st;
float _x;
Signal_transmitter _st;
Semaphore & _sem;
void _calc(float volatile & x, float volatile & y)
{
@ -56,59 +37,50 @@ class Fpu_user : public Thread_deprecated<0x2000>
public:
Fpu_user() : Thread_deprecated("fpu_user"), _x(0), _st(0) { }
void start(float const x, Sync_signal_transmitter * const st)
{
_x = x;
_st = st;
Thread::start();
}
Fpu_user(Env & env, float x, Signal_context_capability c, Semaphore &s)
: Thread(env, "fpu_user", sizeof(size_t)*2048), _x(x), _st(c), _sem(s) {
start(); }
void entry()
{
Genode::log("FPU user started");
bool submitted = false;
while (1) {
enum { TRIALS = 1000 };
for (unsigned i = 0; i < TRIALS; i++) {
float volatile a = _x + (float)i * ((float)1 / TRIALS);
float volatile b = _x + (float)i * ((float)1 / TRIALS);
float volatile c = _x;
_calc(a, c);
_calc(b, c);
if (a != b) {
Genode::error("calculation error");
_st->submit(1);
sleep_forever();
}
}
if (!submitted) {
_st->submit(1);
submitted = true;
log("FPU user started");
enum { TRIALS = 1000 };
for (unsigned i = 0; i < TRIALS; i++) {
float volatile a = _x + (float)i * ((float)1 / TRIALS);
float volatile b = _x + (float)i * ((float)1 / TRIALS);
float volatile c = _x;
_calc(a, c);
_calc(b, c);
if (a != b) {
error("calculation error");
break;
}
}
_sem.up();
_st.submit();
}
};
int main()
{
/* create ack signal */
Signal_context sc;
Signal_receiver sr;
Signal_context_capability const scc = sr.manage(&sc);
Sync_signal_transmitter st(scc);
/* start pseudo-parallel FPU users */
struct Main
{
enum { FPU_USERS = 10 };
Fpu_user fpu_users[FPU_USERS];
for (unsigned i = 0; i < FPU_USERS; i++) {
float const x = (i + 1) * 1.234;
fpu_users[i].start(x, &st);
}
/* wait for an ack of every FPU user */
for (unsigned i = 0; i < FPU_USERS;) { i += sr.wait_for_signal().num(); }
log("test done");
sleep_forever();
return 0;
}
Semaphore sem;
Env & env;
Heap heap { env.ram(), env.rm() };
Signal_handler<Main> handler { env.ep(), *this, &Main::handle };
Main(Env & env) : env(env) {
for (unsigned i = 0; i < FPU_USERS; i++)
new (heap) Fpu_user(env, (i + 1) * 1.234, handler, sem); }
void handle() {
if (sem.cnt() >= FPU_USERS) log("test done"); }
};
void Component::construct(Genode::Env & env) {
static Main main(env); }

31
repos/base/src/test/mp_server/main.cc
View File

@ -13,13 +13,11 @@
*/
/* Genode includes */
#include <base/component.h>
#include <base/heap.h>
#include <base/log.h>
#include <base/thread.h>
#include <base/env.h>
#include <base/sleep.h>
#include <cap_session/connection.h>
#include <base/rpc_server.h>
#include <base/rpc_client.h>
namespace Test {
@ -81,34 +79,35 @@ namespace Test {
/**
* Set up a server running on every CPU one Rpc_entrypoint
*/
int main(int argc, char **argv)
void Component::construct(Genode::Env & env)
{
using namespace Genode;
Heap heap(env.ram(), env.rm());
log("--- test-mp_server started ---");
Affinity::Space cpus = env()->cpu_session()->affinity_space();
Affinity::Space cpus = env.cpu().affinity_space();
log("Detected ", cpus.width(), "x", cpus.height(), " CPU",
cpus.total() > 1 ? "s." : ".");
enum { STACK_SIZE = 2*1024*sizeof(long) };
static Cap_connection cap;
Rpc_entrypoint ** eps = new (env()->heap()) Rpc_entrypoint*[cpus.total()];
Rpc_entrypoint ** eps = new (heap) Rpc_entrypoint*[cpus.total()];
for (unsigned i = 0; i < cpus.total(); i++)
eps[i] = new (env()->heap()) Rpc_entrypoint(&cap, STACK_SIZE, "rpc en",
true, cpus.location_of_index(i));
eps[i] = new (heap) Rpc_entrypoint(&env.pd(), STACK_SIZE, "rpc en",
true, cpus.location_of_index(i));
/* XXX using the same object and putting it to different queues fails XXX */
Test::Component * components = new (env()->heap()) Test::Component[cpus.total()];
Test::Component * components = new (heap) Test::Component[cpus.total()];
Test::Capability * caps = new (env()->heap()) Test::Capability[cpus.total()];
Test::Capability * caps = new (heap) Test::Capability[cpus.total()];
for (unsigned i = 0; i < cpus.total(); i++)
caps[i] = eps[i]->manage(&components[i]);
Test::Client ** clients = new (env()->heap()) Test::Client*[cpus.total()];
Test::Client ** clients = new (heap) Test::Client*[cpus.total()];
for (unsigned i = 0; i < cpus.total(); i++)
clients[i] = new (env()->heap()) Test::Client(caps[i]);
clients[i] = new (heap) Test::Client(caps[i]);
/* Test: Invoke RPC entrypoint on different CPUs */
for (unsigned i = 0; i < cpus.total(); i++) {
@ -132,6 +131,4 @@ int main(int argc, char **argv)
}
log("done");
sleep_forever();
}

48
repos/base/src/test/new_delete/main.cc
View File

@ -12,8 +12,9 @@
* under the terms of the GNU General Public License version 2.
*/
#include <base/component.h>
#include <base/heap.h>
#include <base/log.h>
#include <base/env.h>
using Genode::log;
using Genode::destroy;
@ -40,29 +41,24 @@ struct E : C, D
struct Allocator : Genode::Allocator
{
Genode::Allocator &heap = *Genode::env()->heap();
Genode::Heap heap;
Genode::Allocator & a { heap };
Allocator() { }
Allocator(Genode::Env & env) : heap(env.ram(), env.rm()) { }
virtual ~Allocator() { }
Genode::size_t consumed() const override
{
return heap.consumed();
}
Genode::size_t consumed() const override {
return a.consumed(); }
Genode::size_t overhead(Genode::size_t size) const override
{
return heap.overhead(size);
}
Genode::size_t overhead(Genode::size_t size) const override {
return a.overhead(size); }
bool need_size_for_free() const override
{
return heap.need_size_for_free();
}
bool need_size_for_free() const override {
return a.need_size_for_free(); }
bool alloc(Genode::size_t size, void **p) override
{
*p = heap.alloc(size);
*p = a.alloc(size);
log("Allocator::alloc()");
@ -72,14 +68,14 @@ struct Allocator : Genode::Allocator
void free(void *p, Genode::size_t size) override
{
log("Allocator::free()");
heap.free(p, size);
a.free(p, size);
}
};
int main()
void Component::construct(Genode::Env &env)
{
Allocator a;
Allocator a(env);
/***********************
** Allocator pointer **
@ -87,14 +83,14 @@ int main()
/* test successful allocation / successful construction */
{
E *e = new (&a) E(false);
destroy(&a, e);
E *e = new (a) E(false);
destroy(a, e);
}
/* test successful allocation / exception in construction */
try {
E *e = new (&a) E(true);
destroy(&a, e);
E *e = new (a) E(true);
destroy(a, e);
} catch (...) { log("exception caught"); }
/*************************
@ -104,12 +100,14 @@ int main()
/* test successful allocation / successful construction */
{
E *e = new (a) E(false);
destroy(&a, e);
destroy(a, e);
}
/* test successful allocation / exception in construction */
try {
E *e = new (a) E(true);
destroy(&a, e);
destroy(a, e);
} catch (...) { log("exception caught"); }
log("Test done");
}

2
repos/base/src/test/rm_fault/main.cc
View File

@ -228,7 +228,7 @@ void Component::construct(Env &env)
* Distinguish parent from child by requesting an service that is only
* available to the parent.
*/
Rm_connection rm;
Rm_connection rm(env);
static Main_parent parent(env);
log("-- parent role started --");
}

62
repos/base/src/test/rm_nested/main.cc
View File

@ -18,10 +18,7 @@
* under the terms of the GNU General Public License version 2.
*/
#include <base/env.h>
#include <base/thread.h>
#include <base/signal.h>
#include <cap_session/connection.h>
#include <base/component.h>
#include <rm_session/connection.h>
#include <region_map/client.h>
#include <dataspace/client.h>
@ -38,22 +35,15 @@ enum {
/**
* Region-manager fault handler resolves faults by attaching new dataspaces
*/
class Local_fault_handler : public Thread_deprecated<4096>
class Local_fault_handler : public Entrypoint
{
private:
Region_map &_region_map;
Signal_receiver &_receiver;
Env & _env;
Region_map & _region_map;
Signal_handler<Local_fault_handler> _handler;
public:
Local_fault_handler(Region_map &region_map, Signal_receiver &receiver)
:
Thread_deprecated("local_fault_handler"),
_region_map(region_map), _receiver(receiver)
{ }
void handle_fault()
void _handle_fault()
{
Region_map::State state = _region_map.state();
@ -64,45 +54,44 @@ class Local_fault_handler : public Thread_deprecated<4096>
", pf_addr=", Hex(state.addr, Hex::PREFIX));
log("allocate dataspace and attach it to sub region map");
Dataspace_capability ds = env()->ram_session()->alloc(PAGE_SIZE);
Dataspace_capability ds = _env.ram().alloc(PAGE_SIZE);
_region_map.attach_at(ds, state.addr & ~(PAGE_SIZE - 1));
log("returning from handle_fault");
}
void entry()
public:
Local_fault_handler(Genode::Env & env, Region_map &region_map)
: Entrypoint(env, sizeof(addr_t)*2048, "local_fault_handler"),
_env(env),
_region_map(region_map),
_handler(*this, *this, &Local_fault_handler::_handle_fault)
{
while (true) {
log("fault handler: waiting for fault signal");
Signal signal = _receiver.wait_for_signal();
log("received ", signal.num(), " fault signals");
for (unsigned i = 0; i < signal.num(); i++)
handle_fault();
}
region_map.fault_handler(_handler);
log("fault handler: waiting for fault signal");
}
void dissolve() { Entrypoint::dissolve(_handler); }
};
int main(int argc, char **argv)
void Component::construct(Genode::Env & env)
{
log("--- nested region map test ---");
/*
* Initialize sub region map and set up a local fault handler for it.
*/
static Rm_connection rm;
static Region_map_client region_map(rm.create(MANAGED_SIZE));
static Cap_connection cap;
static Signal_receiver receiver;
static Signal_context context;
region_map.fault_handler(receiver.manage(&context));
static Local_fault_handler fault_handler(region_map, receiver);
fault_handler.start();
static Rm_connection rm(env);
static Region_map_client region_map(rm.create(MANAGED_SIZE));
static Local_fault_handler fault_handler(env, region_map);
/*
* Attach region map as dataspace to the local address space.
*/
void *addr = env()->rm_session()->attach(region_map.dataspace());
void *addr = env.rm().attach(region_map.dataspace());
log("attached sub dataspace at local address ", addr);
Dataspace_client client(region_map.dataspace());
@ -118,12 +107,11 @@ int main(int argc, char **argv)
managed[i] = 13;
}
receiver.dissolve(&context);
fault_handler.dissolve();
log("test destruction of region_map");
Capability<Region_map> rcap = rm.create(4096);
rm.destroy(rcap);
log("--- finished nested region map test ---");
return 0;
}

4
repos/base/src/test/segfault/main.cc
View File

@ -4,12 +4,12 @@
* \date 2012-11-01
*/
#include <base/component.h>
#include <base/log.h>
int main(int argc, char **argv)
void Component::construct(Genode::Env &)
{
Genode::log("going to produce a segmentation fault...");
*((int *)0x44) = 0x55;
return 0;
}

41
repos/base/src/test/slab/main.cc
View File

@ -12,7 +12,8 @@
* under the terms of the GNU General Public License version 2.
*/
#include <base/env.h>
#include <base/component.h>
#include <base/heap.h>
#include <base/slab.h>
#include <base/log.h>
#include <base/allocator_guard.h>
@ -26,7 +27,8 @@ using Genode::error;
struct Array_of_slab_elements
{
Genode::Slab &slab;
Genode::Slab & slab;
Genode::Allocator & alloc;
size_t const num_elem;
size_t const slab_size;
@ -40,21 +42,14 @@ struct Array_of_slab_elements
struct Alloc_failed { };
/**
* Constructor
*
* \throw Alloc_failed
*/
Array_of_slab_elements(Genode::Slab &slab, size_t num_elem, size_t slab_size)
:
slab(slab), num_elem(num_elem), slab_size(slab_size)
Array_of_slab_elements(Genode::Slab &slab, size_t num_elem, size_t slab_size,
Genode::Allocator & alloc)
: slab(slab), alloc(alloc), num_elem(num_elem), slab_size(slab_size),
elem((void**) alloc.alloc(_elem_array_size()))
{
elem = (void **)Genode::env()->heap()->alloc(_elem_array_size());
log(" allocate ", num_elem, " elements");
for (size_t i = 0; i < num_elem; i++)
if (!slab.alloc(slab_size, &elem[i]))
throw Alloc_failed();
if (!slab.alloc(slab_size, &elem[i])) throw Alloc_failed();
}
~Array_of_slab_elements()
@ -63,19 +58,21 @@ struct Array_of_slab_elements
for (size_t i = 0; i < num_elem; i++)
slab.free(elem[i], slab_size);
Genode::env()->heap()->free(elem, _elem_array_size());
alloc.free(elem, _elem_array_size());
}
};
int main(int argc, char **argv)
void Component::construct(Genode::Env & env)
{
Genode::Heap heap(env.ram(), env.rm());
log("--- slab test ---");
static Timer::Connection timer;
static Timer::Connection timer(env);
enum { SLAB_SIZE = 16, BLOCK_SIZE = 256 };
static Genode::Allocator_guard alloc(Genode::env()->heap(), ~0UL);
static Genode::Allocator_guard alloc(&heap, ~0UL);
{
Genode::Slab slab(SLAB_SIZE, BLOCK_SIZE, nullptr, &alloc);
@ -85,7 +82,7 @@ int main(int argc, char **argv)
"used quota: ", alloc.consumed(), " "
"time: ", timer.elapsed_ms(), " ms)");
Array_of_slab_elements array(slab, i*100000, SLAB_SIZE);
Array_of_slab_elements array(slab, i*100000, SLAB_SIZE, heap);
log(" allocation completed (used quota: ", alloc.consumed(), ")");
}
@ -100,7 +97,7 @@ int main(int argc, char **argv)
enum { HEAP_OVERHEAD = 36 };
if (alloc.consumed() > 2*(BLOCK_SIZE + HEAP_OVERHEAD)) {
error("slab failed to release empty slab blocks");
return -1;
return;
}
}
@ -108,8 +105,8 @@ int main(int argc, char **argv)
log("destructed slab (used quota: ", alloc.consumed(), ")");
if (alloc.consumed() > 0) {
error("slab failed to release all backing store");
return -2;
return;
}
return 0;
log("Test done");
}

9
repos/base/src/test/util_mmio/main.cc
View File

@ -12,8 +12,9 @@
*/
/* Genode includes */
#include <util/mmio.h>
#include <base/component.h>
#include <base/log.h>
#include <util/mmio.h>
using namespace Genode;
@ -186,8 +187,11 @@ int compare_mem(uint8_t * base1, uint8_t * base2, size_t size)
void error(unsigned line) { error("Test in line ", line, " failed"); }
int main()
void Component::construct(Genode::Env &)
{
using ::Cpu_state;
/************************************
** 'Genode::Mmio::Register' tests **
************************************/
@ -465,6 +469,5 @@ int main()
}
log("Test done");
return 0;
}

59
repos/base/src/test/weak_ptr/main.cc
View File

@ -12,8 +12,9 @@
*/
/* Genode includes */
#include <base/component.h>
#include <base/log.h>
#include <base/env.h>
#include <base/heap.h>
#include <base/thread.h>
#include <base/weak_ptr.h>
#include <timer_session/connection.h>
@ -35,7 +36,7 @@ void Genode::Weak_object_base::debug_info() const
}
static int weak_ptr_valid;
static bool weak_ptr_valid;
void Genode::Weak_ptr_base::debug_info() const
@ -91,7 +92,7 @@ struct Object : Genode::Weak_object<Object>
};
static void test_weak_pointer_tracking()
static void test_weak_pointer_tracking(Genode::Heap & heap)
{
using namespace Genode;
@ -101,7 +102,7 @@ static void test_weak_pointer_tracking()
assert_weak_ptr_valid(ptr, false);
}
Object *obj = new (env()->heap()) Object;
Object *obj = new (heap) Object;
Weak_ptr<Object> ptr_1 = obj->weak_ptr();
assert_weak_ptr_valid(ptr_1, true);
@ -127,7 +128,7 @@ static void test_weak_pointer_tracking()
assert_weak_ptr_cnt(obj, 2);
log("destruct object");
destroy(env()->heap(), obj);
destroy(heap, obj);
/*
* The destruction of the object should have invalidated all weak pointers
@ -143,19 +144,21 @@ static void test_weak_pointer_tracking()
*******************************************/
template <typename O>
struct Destruct_thread : Genode::Thread_deprecated<4096>
struct Destruct_thread : Genode::Thread
{
O *obj;
Genode::Heap & heap;
void entry()
{
using namespace Genode;
log("thread: going to destroy object");
destroy(env()->heap(), obj);
destroy(heap, obj);
log("thread: destruction completed, job done");
}
Destruct_thread(O *obj) : Thread_deprecated("object_destructor"), obj(obj) { }
Destruct_thread(O *obj, Genode::Env & env, Genode::Heap & heap)
: Thread(env, "object_destructor", 4096), obj(obj), heap(heap) { }
};
@ -170,13 +173,13 @@ static void assert_constructed(bool expect_constructed)
}
static void test_deferred_destruction()
static void test_deferred_destruction(Genode::Env & env, Genode::Heap &heap)
{
using namespace Genode;
static Timer::Connection timer;
static Timer::Connection timer(env);
Object *obj = new (env()->heap()) Object;
Object *obj = new (&heap) Object;
Weak_ptr<Object> ptr = obj->weak_ptr();
assert_weak_ptr_cnt(obj, 1);
@ -184,7 +187,7 @@ static void test_deferred_destruction()
assert_constructed(true);
/* create thread that will be used to destruct the object */
Destruct_thread<Object> destruct_thread(obj);
Destruct_thread<Object> destruct_thread(obj, env, heap);
{
/* acquire possession over the object */
@ -218,12 +221,12 @@ static void test_deferred_destruction()
** Test the failed aquisition of a destructed object **
*******************************************************/
static void test_acquisition_failure()
static void test_acquisition_failure(Genode::Heap & heap)
{
using namespace Genode;
log("create object and weak pointer");
Object *obj = new (env()->heap()) Object;
Object *obj = new (&heap) Object;
Weak_ptr<Object> ptr = obj->weak_ptr();
log("try to acquire possession over the object");
@ -239,7 +242,7 @@ static void test_acquisition_failure()
}
log("destroy object");
destroy(env()->heap(), obj);
destroy(&heap, obj);
log("try again, this time we should get an invalid pointer");
{
@ -262,7 +265,8 @@ struct Object_with_delayed_destruction
{
Timer::Connection timer;
Object_with_delayed_destruction() { object_constructed = true; }
Object_with_delayed_destruction(Genode::Env & env) : timer(env) {
object_constructed = true; }
~Object_with_delayed_destruction()
{
@ -273,14 +277,16 @@ struct Object_with_delayed_destruction
};
static void test_acquisition_during_destruction()
static void test_acquisition_during_destruction(Genode::Env & env,
Genode::Heap & heap)
{
using namespace Genode;
using Destruct_thread = Destruct_thread<Object_with_delayed_destruction>;
static Timer::Connection timer;
static Timer::Connection timer(env);
Object_with_delayed_destruction *obj =
new (env()->heap()) Object_with_delayed_destruction();
new (&heap) Object_with_delayed_destruction(env);
Weak_ptr<Object_with_delayed_destruction> ptr = obj->weak_ptr();
assert_weak_ptr_cnt(obj, 1);
@ -288,7 +294,7 @@ static void test_acquisition_during_destruction()
assert_constructed(true);
/* create and start thread that will be used to destruct the object */
Destruct_thread<Object_with_delayed_destruction> destruct_thread(obj);
Destruct_thread destruct_thread(obj, env, heap);
destruct_thread.start();
/* wait so that the thread enters the destructor */
@ -310,24 +316,25 @@ static void test_acquisition_during_destruction()
** Main program **
******************/
int main(int argc, char **argv)
void Component::construct(Genode::Env & env)
{
using namespace Genode;
Heap heap(env.ram(), env.rm());
log("--- test-weak_ptr started ---");
log("\n-- test tracking of weak pointers --");
test_weak_pointer_tracking();
test_weak_pointer_tracking(heap);
log("\n-- test deferred destruction --");
test_deferred_destruction();
test_deferred_destruction(env, heap);
log("\n-- test acquisition failure --");
test_acquisition_failure();
test_acquisition_failure(heap);
log("\n-- test acquisition during destruction --");
test_acquisition_during_destruction();
test_acquisition_during_destruction(env, heap);
log("\n--- finished test-weak_ptr ---");
return 0;
}