├── benchmarks
    ├── deretta-coroutine
    │   ├── boost
    │   │   └── coroutine
    │   │   │   ├── tags
    │   │   │   ├── detail
    │   │   │       ├── arg_max.hpp
    │   │   │       ├── swap_context.hpp
    │   │   │       ├── index.hpp
    │   │   │       ├── yield_result_type.hpp
    │   │   │       ├── fix_result.hpp
    │   │   │       ├── noreturn.hpp
    │   │   │       ├── signal.hpp
    │   │   │       ├── is_callable.hpp
    │   │   │       ├── signature.hpp
    │   │   │       ├── has_swap.hpp
    │   │   │       ├── make_tuple_traits.hpp
    │   │   │       ├── coroutine_traits.hpp
    │   │   │       ├── coroutine_accessor.hpp
    │   │   │       ├── argument_packer.hpp
    │   │   │       ├── wait_impl.hpp
    │   │   │       ├── future_impl.hpp
    │   │   │       ├── call_impl.hpp
    │   │   │       └── posix_utility.hpp
    │   │   │   ├── shared_coroutine.hpp
    │   │   │   └── exception.hpp
    │   └── libs
    │   │   └── coroutine
    │   │       ├── benchmark
    │   │           ├── make.sh
    │   │           ├── Jamfile
    │   │           └── out_of_line.cpp
    │   │       ├── src
    │   │           ├── coroutine.cpp
    │   │           ├── swapcontext.s
    │   │           └── swapcontext.cpp
    │   │       ├── test
    │   │           ├── test_invoke.cpp
    │   │           ├── test_optional.cpp
    │   │           ├── test_yield.cpp
    │   │           ├── test_yield_to2.cpp
    │   │           ├── test_yield_to.cpp
    │   │           ├── test_reference.cpp
    │   │           ├── test_meta.cpp
    │   │           ├── Jamfile.v2
    │   │           ├── test_non_default_constructible.cpp
    │   │           ├── test_any.cpp
    │   │           ├── test_move.cpp
    │   │           ├── test_generator.cpp
    │   │           ├── test_call.cpp
    │   │           └── test_create.cpp
    │   │       ├── build
    │   │           └── Jamfile.v2
    │   │       ├── example
    │   │           ├── factorial.cpp
    │   │           ├── switch_fsm.cpp
    │   │           ├── consumer_producer_b.cpp
    │   │           ├── matcher.cpp
    │   │           ├── scheduler.cpp
    │   │           ├── Jamfile.v2
    │   │           ├── coroutine_fsm_regexp.cpp
    │   │           ├── consumer_producer_a.cpp
    │   │           ├── banana.cpp
    │   │           ├── consumer_producer_c.cpp
    │   │           └── scheduler_wait.cpp
    │   │       └── doc
    │   │           └── Jamfile.v2
    ├── posixContext.cpp
    ├── oslinuxContext.cpp
    ├── oslinuxContextLoop.cpp
    ├── posixContextLoop.cpp
    ├── include
    │   ├── benchmark
    │   │   ├── clock.hpp
    │   │   ├── details
    │   │   │   └── posix.hpp
    │   │   └── timer.hpp
    │   └── benchmark.hpp
    ├── stack.cpp
    ├── virtcall.cpp
    ├── coroutine.cpp
    ├── CMakeLists.txt
    ├── context.cpp.inc
    ├── context_loop.cpp.inc
    └── stats.py
├── tests
    ├── stack
    │   ├── CMakeLists.txt
    │   └── stack.cpp
    ├── context
    │   ├── posixContext.cpp
    │   ├── CMakeLists.txt
    │   ├── oslinuxContext.cpp
    │   ├── oslinuxABIcheck.cpp
    │   └── context.cpp.inc
    ├── coroutine
    │   ├── CMakeLists.txt
    │   ├── builder.cpp
    │   ├── yielder.cpp
    │   ├── exception.cpp
    │   └── coroutine.cpp
    ├── include
    │   └── test.hpp
    └── CMakeLists.txt
├── README
├── include
    └── coroutine
    │   ├── impl
    │       ├── stack_static.hpp
    │       ├── context_linux.hpp
    │       ├── stack_dynamic.hpp
    │       ├── context_posix.hpp
    │       └── context_linux_x86_32.hpp
    │   ├── best_context.hpp
    │   ├── context.hpp
    │   ├── stack.hpp
    │   └── yielder.hpp
└── CMakeLists.txt


/benchmarks/deretta-coroutine/boost/coroutine/tags:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bombela/CxxCoroutine/HEAD/benchmarks/deretta-coroutine/boost/coroutine/tags


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/benchmark/make.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | BOOST_ROOT=~/src/boost bjam -sBUILD="<optimization>speed <inlining>on" -d2
3 | 


--------------------------------------------------------------------------------
/tests/stack/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #
 2 | # CMakeLists.txt
 3 | # Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 | #
 5 | #
 6 | 
 7 | set(TEST_SRCS
 8 | 	stack.cpp
 9 | )
10 | 
11 | foreach(f ${TEST_SRCS})
12 | 	coroutine_add_test(${f})
13 | endforeach()
14 | 


--------------------------------------------------------------------------------
/tests/context/posixContext.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * posixContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <test.hpp>
 8 | #include <coroutine/impl/context_posix.hpp>
 9 | 
10 | typedef coroutine::context::posix context_tag;
11 | 
12 | #include "context.cpp.inc"
13 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | Need cmake and boost to build.
 2 | 
 3 | configure:
 4 | 	mkdir build
 5 | 	cd build
 6 | 	cmake -DCMAKE_BUILD_TYPE=Release ..
 7 | 
 8 | build:
 9 | 	make
10 | 
11 | run test:
12 | 	make test
13 | 
14 | run benchmarks:
15 | 	make bench
16 | 
17 | show nice benchmarks stats (need python and plotlib for python):
18 | 	make stat
19 | 


--------------------------------------------------------------------------------
/tests/context/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #
 2 | # CMakeLists.txt
 3 | # Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 | #
 5 | #
 6 | 
 7 | set(TEST_SRCS
 8 | 	posixContext.cpp
 9 | 	oslinuxContext.cpp
10 | 	oslinuxABIcheck.cpp
11 | )
12 | 
13 | foreach(f ${TEST_SRCS})
14 | 	coroutine_add_test(${f})
15 | endforeach()
16 | 


--------------------------------------------------------------------------------
/tests/context/oslinuxContext.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * oslinuxContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <test.hpp>
 8 | #include <coroutine/impl/context_linux.hpp>
 9 | 
10 | typedef coroutine::context::linux context_tag;
11 | 
12 | #include "context.cpp.inc"
13 | 


--------------------------------------------------------------------------------
/tests/coroutine/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #
 2 | # CMakeLists.txt
 3 | # Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 | #
 5 | #
 6 | 
 7 | set(TEST_SRCS
 8 | 	yielder.cpp
 9 | 	builder.cpp
10 | 	coroutine.cpp
11 | 	exception.cpp
12 | )
13 | 
14 | foreach(f ${TEST_SRCS})
15 | 	coroutine_add_test(${f})
16 | endforeach()
17 | 


--------------------------------------------------------------------------------
/benchmarks/posixContext.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * posixContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | #include <coroutine/impl/context_posix.hpp>
 9 | 
10 | typedef coroutine::context::posix context_tag;
11 | 
12 | #define BENCH_ARCH posix
13 | #include "context.cpp.inc"
14 | 
15 | BENCH_MAIN(fullbench)
16 | 


--------------------------------------------------------------------------------
/benchmarks/oslinuxContext.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * oslinuxContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | #include <coroutine/impl/context_linux.hpp>
 9 | 
10 | typedef coroutine::context::linux context_tag;
11 | 
12 | #define BENCH_ARCH oslinux
13 | #include "context.cpp.inc"
14 | 
15 | BENCH_MAIN(fullbench)
16 | 


--------------------------------------------------------------------------------
/benchmarks/oslinuxContextLoop.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * oslinuxContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | #include <coroutine/impl/context_linux.hpp>
 9 | 
10 | typedef coroutine::context::linux context_tag;
11 | 
12 | #define BENCH_ARCH oslinux
13 | #include "context_loop.cpp.inc"
14 | 
15 | BENCH_MAIN(loope)
16 | 


--------------------------------------------------------------------------------
/tests/include/test.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * test.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef TEST_H
 9 | #define TEST_H
10 | 
11 | #define BOOST_TEST_MODULE coroutine
12 | #include <boost/test/unit_test.hpp>
13 | 
14 | #define UNUSED __attribute__ ((unused))
15 | #define NOINLINE __attribute__ ((noinline))
16 | 
17 | #endif /* TEST_H */
18 | 


--------------------------------------------------------------------------------
/benchmarks/posixContextLoop.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * posixContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | #include <coroutine/impl/context_posix.hpp>
 9 | 
10 | typedef coroutine::context::posix context_tag;
11 | 
12 | #define BENCH_ARCH posix
13 | #define BENCH_ARCH_POSIX
14 | #include "context_loop.cpp.inc"
15 | 
16 | BENCH_MAIN(loop)
17 | 


--------------------------------------------------------------------------------
/benchmarks/include/benchmark/clock.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * clock.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef CLOCK_H
 9 | #define CLOCK_H
10 | 
11 | #include <cstdio>
12 | 
13 | #ifdef __USE_POSIX
14 | #	include <benchmark/details/posix.hpp>
15 | namespace benchmark {
16 | namespace clock = benchmark::details::clock::posix;
17 | } // namespace benchmark
18 | #else
19 | #	error Non posix system not yet supported!
20 | #endif
21 | 
22 | #endif /* CLOCK_H */
23 | 


--------------------------------------------------------------------------------
/benchmarks/stack.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * stack.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | #include <coroutine/stack.hpp>
 9 | #include <coroutine/impl/stack_static.hpp>
10 | #include <coroutine/impl/stack_dynamic.hpp>
11 | 
12 | using namespace coroutine;
13 | 
14 | BENCH(createStack_static, 23)
15 | {
16 | 	UNUSED stack::stack<stack::static_, 1024 * 1024 * 2> stack;
17 | }
18 | 
19 | BENCH(createStack_dynamic, 23)
20 | {
21 | 	UNUSED stack::stack<stack::dynamic, 1024 * 1024 * 2> stack;
22 | }
23 | 
24 | BENCH_MAIN(fullbench)
25 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/benchmark/Jamfile:
--------------------------------------------------------------------------------
 1 | subproject libs/coroutine/benchmark ;
 2 |                                                                                                                                                               
 3 | project boost : $(BOOST_ROOT) ;                                                 
 4 | 
 5 | flags gcc CFLAGS <optimization>speed: -finline ;
 6 |                                                                               
 7 | template example
 8 | 	: <lib>../build/boost_coroutine
 9 | 	: <include>../../..
10 | 	;
11 | 
12 | exe call_overhead : call_overhead.cpp out_of_line.cpp <template>example ;
13 | 
14 | 
15 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #
 2 | # CMakeLists.txt
 3 | # Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 | #
 5 | #
 6 | 
 7 | find_package(Boost 1.38 REQUIRED system unit_test_framework test_exec_monitor)
 8 | include_directories(${Boost_INCLUDE_DIRS})
 9 | link_libraries(${Boost_LIBRARIES})
10 | 
11 | macro(coroutine_add_test src)
12 | 	get_filename_component(name ${src} NAME_WE)
13 | 	set(name "test_${name}")
14 | 	add_executable(${name} ${src})
15 | 	add_test(${name} ${name})
16 | endmacro()
17 | 
18 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
19 | 
20 | add_subdirectory(stack)
21 | add_subdirectory(context)
22 | add_subdirectory(coroutine)
23 | 


--------------------------------------------------------------------------------
/benchmarks/virtcall.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * virtcall.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | 
 9 | namespace {
10 | 
11 | class Interface
12 | {
13 | 	public:
14 | 		virtual ~Interface() {}
15 | 		virtual void doTest() = 0;
16 | };
17 | 
18 | class Virtcall: public Interface
19 | {
20 | 	public:
21 | 		virtual void doTest();
22 | };
23 | 
24 | void Virtcall::doTest() {}
25 | 
26 | struct BenchContext
27 | {
28 | 	BenchContext(): obj(new Virtcall) {}
29 | 	~BenchContext() { delete obj; }
30 | 
31 | 	Interface* obj;
32 | } bench;
33 | 
34 | } // namespace
35 | 
36 | BENCH(virtcall, 24)
37 | {
38 | 	bench.obj->doTest();
39 | }
40 | 
41 | BENCH_MAIN(fullbench)
42 | 


--------------------------------------------------------------------------------
/include/coroutine/impl/stack_static.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * stack_static.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef STACK_STATIC_H
 9 | #define STACK_STATIC_H
10 | 
11 | namespace coroutine {
12 | 	namespace stack {
13 | 
14 | 		struct static_: stack_tag {};
15 | 
16 | 		template <size_t SSIZE>
17 | 			class stack<static_, SSIZE> {
18 | 				static const size_t size = SSIZE;
19 | 
20 | 				public:
21 | 					static size_t get_size() { return size; }
22 | 					char* get_stack_ptr() { return _stack; }
23 | 
24 | 					stack() {}
25 | 					stack(const stack& from) = delete;
26 | 					stack& operator=(const stack& from) = delete;
27 | 					stack& operator=(stack&& from) = delete;
28 | 
29 | 					stack(stack&&) { }
30 | 
31 | 				private:
32 | 					char _stack[size];
33 | 			};
34 | 
35 | 	} // namespace stack
36 | } // namespace coroutine
37 | 
38 | #endif /* STACK_STATIC_H */
39 | 


--------------------------------------------------------------------------------
/include/coroutine/impl/context_linux.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * context_linux.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef CONTEXT_LINUX_H
 9 | #define CONTEXT_LINUX_H
10 | 
11 | 
12 | #if   __SIZEOF_POINTER__ == 8
13 | #	include <coroutine/impl/context_linux_x86_64.hpp>
14 | 
15 | namespace coroutine {
16 | 	namespace context {
17 | 		struct linux: context_tag {
18 | 			typedef linux_x86_64 alias;
19 | 		};
20 | 	} // namespace context
21 | } // namespace coroutine
22 | 
23 | #elif __SIZEOF_POINTER__ == 4
24 | #	include <coroutine/impl/context_linux_x86_32.hpp>
25 | 
26 | namespace coroutine {
27 | 	namespace context {
28 | 		struct linux: context_tag {
29 | 			typedef linux_x86_32 alias;
30 | 		};
31 | 	} // namespace context
32 | } // namespace coroutine
33 | 
34 | #else
35 | #	error "architecture pointer size not supported"
36 | #endif
37 | 
38 | #endif /* CONTEXT_LINUX_H */
39 | 


--------------------------------------------------------------------------------
/include/coroutine/best_context.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * best_context.hpp
 3 |  * Copyright © 2011 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef BEST_CONTEXT_H
 9 | #define BEST_CONTEXT_H
10 | 
11 | #include <coroutine/context.hpp>
12 | 
13 | #if defined(__linux__)
14 | #	include <coroutine/impl/context_linux.hpp>
15 | 
16 | namespace coroutine {
17 | 	namespace context {
18 | 
19 | 		struct best: context_tag {
20 | 			typedef linux alias;
21 | 		};
22 | 
23 | 	} // namespace context
24 | } // namespace coroutine
25 | 
26 | #elif defined(__USE_POSIX)
27 | #	include <coroutine/impl/context_posix.hpp>
28 | 
29 | namespace coroutine {
30 | 	namespace context {
31 | 		struct best: context_tag {
32 | 			typedef posix alias;
33 | 		};
34 | 
35 | 	} // namespace context
36 | } // namespace coroutine
37 | 
38 | #else
39 | #	error Failed to determind the best context for the current system.
40 | #endif
41 | 
42 | #endif /* BEST_CONTEXT_H */
43 | 


--------------------------------------------------------------------------------
/benchmarks/coroutine.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * stack.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <benchmark.hpp>
 8 | #include <coroutine/stack.hpp>
 9 | #include <coroutine/builder.hpp>
10 | #include <coroutine/stack.hpp>
11 | #include <iostream>
12 | 
13 | using namespace coroutine;
14 | 
15 | const long int LOOP_SIZE = 1L << 27;
16 | 
17 | void empty_coro(yielder<void ()> yield) {
18 | 	for (long int i = 0; i < LOOP_SIZE; ++i)
19 | 		yield();
20 | 	abort();
21 | }
22 | 
23 | __attribute__((noinline)) void dothebench() {
24 | 	auto c = corof(empty_coro);
25 | 	for (long long int i = 0; i < LOOP_SIZE; ++i)
26 | 		c();
27 | }
28 | 
29 | BENCH(coroutine, 3)
30 | {
31 | 	dothebench();
32 | }
33 | 
34 | 
35 | __attribute__((noinline)) void dothebench2() {
36 | 	auto c = corof(empty_coro);
37 | 	for (long long int i = 0; i < LOOP_SIZE; ++i)
38 | 		asm("nop");
39 | }
40 | 
41 | BENCH(simpleloop, 3)
42 | {
43 | 	dothebench2();
44 | }
45 | 
46 | BENCH_MAIN(fullbench)
47 | 


--------------------------------------------------------------------------------
/benchmarks/include/benchmark/details/posix.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * posix.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef POSIX_H
 9 | #define POSIX_H
10 | 
11 | #include <stdexcept>
12 | #include <time.h>
13 | #include <stdint.h>
14 | #include <iostream>
15 | namespace benchmark {
16 | namespace details {
17 | namespace clock {
18 | namespace posix {
19 | 
20 | typedef int64_t nanos_t;
21 | 
22 | inline nanos_t res()
23 | {
24 | 	timespec res;
25 | 
26 | 	if (clock_getres(CLOCK_PROCESS_CPUTIME_ID, &res) != 0)
27 | 		throw std::runtime_error("clock_getres");
28 | 
29 | 	return (nanos_t)res.tv_sec * 1000000000 + res.tv_nsec;
30 | }
31 | 
32 | inline nanos_t time()
33 | {
34 | 	timespec ts;
35 | 
36 | 	if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) != 0)
37 | 		throw std::runtime_error("clock_gettime");
38 | 
39 | 	return (nanos_t)ts.tv_sec * 1000000000 + ts.tv_nsec;
40 | }
41 | 
42 | } // namespace posix
43 | } // namespace clock
44 | } // namespace details
45 | } // namespace benchmark
46 | 
47 | #endif /* POSIX_H */
48 | 


--------------------------------------------------------------------------------
/include/coroutine/impl/stack_dynamic.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * stack_dynamic.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef STACK_DYNAMIC_H
 9 | #define STACK_DYNAMIC_H
10 | 
11 | #include <algorithm>
12 | #include <coroutine/stack.hpp>
13 | #include <cstdlib>
14 | 
15 | namespace coroutine {
16 | 	namespace stack {
17 | 
18 | 		struct dynamic: stack_tag {
19 | 			static const bool really_moveable = true;
20 | 		};
21 | 
22 | 		template <size_t SSIZE>
23 | 			class stack<dynamic, SSIZE> {
24 | 				static const size_t size = SSIZE;
25 | 
26 | 				public:
27 | 					stack(): _stack((char*)::malloc(size)) { }
28 | 					~stack() { ::free(_stack); }
29 | 
30 | 					stack(const stack& from) = delete;
31 | 					stack& operator=(const stack& from) = delete;
32 | 					stack& operator=(stack&& from) = delete;
33 | 
34 | 					stack(stack&& from): _stack(from._stack) {
35 | 						from._stack = 0;
36 | 					}
37 | 
38 | 					static size_t get_size() { return size; }
39 | 					char* get_stack_ptr() { return _stack; }
40 | 
41 | 				private:
42 | 					char* _stack;
43 | 			};
44 | 
45 | 	} // namespace stack
46 | } // namespace coroutine
47 | 
48 | #endif /* STACK_DYNAMIC_H */
49 | 


--------------------------------------------------------------------------------
/benchmarks/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #
 2 | # CMakeLists.txt
 3 | # Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 | #
 5 | #
 6 | 
 7 | find_package(Boost 1.38 REQUIRED system)
 8 | include_directories(${Boost_INCLUDE_DIRS})
 9 | link_libraries(${Boost_LIBRARIES})
10 | 
11 | add_custom_target(bench)
12 | 
13 | add_custom_target(cleanbench
14 | 	COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_CURRENT_BINARY_DIR}/bench.log
15 | 	VERBATIM
16 | 	)
17 | 
18 | add_custom_target(stat
19 | 	${CMAKE_CURRENT_SOURCE_DIR}/stats.py ${CMAKE_CURRENT_BINARY_DIR}/bench.log
20 | 	)
21 | 
22 | macro(coroutine_add_bench src)
23 | 	get_filename_component(name ${src} NAME_WE)
24 | 	set(name "bench_${name}")
25 | 	add_executable(${name} ${src})
26 | 	set(runname "${name}.run")
27 | 	add_custom_target(${runname}
28 | 		echo "Benchmarking ${name}..."
29 | 		COMMAND ${name}
30 | 		VERBATIM
31 | 		)
32 | 	add_dependencies(bench ${runname})
33 | endmacro()
34 | 
35 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
36 | 
37 | set(BENCH_SRCS
38 | 	virtcall.cpp
39 | 	stack.cpp
40 | 	posixContext.cpp
41 | 	posixContextLoop.cpp
42 | 	oslinuxContext.cpp
43 | 	oslinuxContextLoop.cpp
44 | 	coroutine.cpp
45 | )
46 | 
47 | foreach(f ${BENCH_SRCS})
48 | 	coroutine_add_bench(${f})
49 | endforeach()
50 | 


--------------------------------------------------------------------------------
/benchmarks/include/benchmark/timer.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * timer.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef TIMER_H
 9 | #define TIMER_H
10 | 
11 | #include <benchmark/clock.hpp>
12 | #include <iostream>
13 | #include <sstream>
14 | #include <fstream>
15 | 
16 | namespace benchmark {
17 | 
18 | class Timer
19 | {
20 | 	public:
21 | 		Timer(const char* pkg,
22 | 				const char* name,
23 | 				const char* relto,
24 | 				int cnt):
25 | 			_pkg(pkg),
26 | 			_name(name),
27 | 			_relto(relto),
28 | 			_cnt(cnt),
29 | 			_start(clock::time()) { }
30 | 		~Timer()
31 | 		{
32 | 			clock::nanos_t diff = clock::time() - _start;
33 | 			std::ostringstream os;
34 | 			os
35 | 				<< "elapsed=" << diff << "nsec, "
36 | 				<< "cnt=" << _cnt << ", "
37 | 				<< "res=" << clock::res() << "nsec, "
38 | 				<< "pkg=" << _pkg << ", "
39 | 				<< "name=" << _name << ", "
40 | 				<< "relto=" << _relto;
41 | 			const std::string& record = os.str();
42 | 			std::cout << record << std::endl;
43 | 			std::ofstream of("bench.log", std::ios_base::app);
44 | 			of << record << std::endl;
45 | 		}
46 | 
47 | 	private:
48 | 		const char*    _pkg;
49 | 		const char*    _name;
50 | 		const char*    _relto;
51 | 		int            _cnt;
52 | 		clock::nanos_t _start;
53 | };
54 | 
55 | } // namespace benchmark
56 | 
57 | #endif /* TIMER_H */
58 | 


--------------------------------------------------------------------------------
/tests/coroutine/builder.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * builder.cpp
 3 |  * Copyright © 2011 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <test.hpp>
 8 | #include <coroutine/builder.hpp>
 9 | #include <coroutine/impl/context_posix.hpp>
10 | 
11 | #include<iostream>
12 | 
13 | using namespace coroutine;
14 | 
15 | int f(yielder<int ()>) { return 42; }
16 | void f2(yielder<>) { }
17 | struct F { int operator()(yielder<int ()>) const { return 42; } };
18 | 
19 | BOOST_AUTO_TEST_CASE(try_to_compile)
20 | {
21 | 	auto c1 = coro<int ()>(F());
22 | 	auto c2 = coro<int ()
23 | 		 ,context::posix
24 | 		 ,stack::static_
25 | 		 >(F());
26 | 	auto c3 = coro<int (),
27 | 		 stack::size_in_kb<42>
28 | 			 >(&f);
29 | 
30 | 	typedef builder<int (), F, stack::size_in_b<42> > coro_info_t;
31 | 
32 | 	BOOST_CHECK(coro_info_t::stack_size == 42);
33 | }
34 | 
35 | void allvoid(yielder<void ()>) {}
36 | 
37 | template <typename T>
38 | 	void do_extraction(T) {
39 | 		typename details::extract_signature<T>::type* a = (void (*)())0;
40 | 	}
41 | 
42 | int alittlefunc(yielder<int (float)>, float) {}
43 | 
44 | template <typename T>
45 | 	void do_extraction2(T) {
46 | 		typename details::extract_signature<T>::type* a = (int (*)(float))0;
47 | 	}
48 | 
49 | BOOST_AUTO_TEST_CASE(extract_signature)
50 | {
51 | 	do_extraction(&allvoid);
52 | 	do_extraction2(&alittlefunc);
53 | }
54 | 
55 | BOOST_AUTO_TEST_CASE(fcoro)
56 | {
57 | 	auto a = corof(&allvoid);
58 | 	auto b = corof(&alittlefunc);
59 | }
60 | 


--------------------------------------------------------------------------------
/tests/coroutine/yielder.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * yielder.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <test.hpp>
 8 | #include <coroutine/yielder.hpp>
 9 | 
10 | using namespace coroutine;
11 | 
12 | BOOST_AUTO_TEST_CASE(create)
13 | {
14 | 	yielder<double (float)> y1(0, 0); // double f(float)
15 | 	yielder<int ()> y2(0, 0); // int f()
16 | 	yielder<void (long)> y3(0, 0); // void f(long)
17 | 	yielder<> y4(0, 0); // void f()
18 | }
19 | 
20 | int someobj;
21 | 
22 | void cb_voidcall(void* a)
23 | {
24 | 	BOOST_CHECK_EQUAL(a, &someobj);
25 | }
26 | 
27 | BOOST_AUTO_TEST_CASE(voidcall)
28 | {
29 | 	yielder<> y(&cb_voidcall, &someobj);
30 | 
31 | 	y();
32 | }
33 | 
34 | void cb_argcall(void* a, int b)
35 | {
36 | 	BOOST_CHECK_EQUAL(a, &someobj);
37 | 	BOOST_CHECK_EQUAL(b, 42);
38 | }
39 | 
40 | BOOST_AUTO_TEST_CASE(argcall)
41 | {
42 | 	yielder<int ()> y(&cb_argcall, &someobj);
43 | 
44 | 	y(42);
45 | }
46 | 
47 | int cb_voidcall_return(void* a)
48 | {
49 | 	BOOST_CHECK_EQUAL(a, &someobj);
50 | 	return 99;
51 | }
52 | 
53 | BOOST_AUTO_TEST_CASE(voidcall_return)
54 | {
55 |     yielder<void (int)> y(&cb_voidcall_return, &someobj);
56 | 
57 | 	BOOST_CHECK_EQUAL(y(), 99);
58 | }
59 | 
60 | float cb_argcall_return(void* a, int b)
61 | {
62 | 	BOOST_CHECK_EQUAL(a, &someobj);
63 | 	BOOST_CHECK_EQUAL(b, 45);
64 | 	return 98;
65 | }
66 | 
67 | BOOST_AUTO_TEST_CASE(argcall_return)
68 | {
69 | 	yielder<int (float)> y(&cb_argcall_return, &someobj);
70 | 
71 | 	BOOST_CHECK_EQUAL(y(45), 98);
72 | }
73 | 


--------------------------------------------------------------------------------
/benchmarks/context.cpp.inc:
--------------------------------------------------------------------------------
 1 | /* vim: ft=cpp
 2 |  * posixContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <coroutine/impl/stack_static.hpp>
 8 | #include <coroutine/impl/stack_dynamic.hpp>
 9 | 
10 | #ifndef BENCH_TYPE
11 | 
12 | #define BENCH_NAME(n) BENCH_CAT(n, BENCH_CAT(BENCH_TYPE, BENCH_CAT(_, BENCH_ARCH)))
13 | 
14 | static const size_t stack_size = 2 * 1024 * 1024;
15 | 
16 | #define BENCH_TYPE _static
17 | #define STACK stack::static_
18 | #include "context.cpp.inc"
19 | #undef STACK
20 | #undef BENCH_TYPE
21 | 
22 | #define BENCH_TYPE _dynamic
23 | #define STACK stack::dynamic
24 | #include "context.cpp.inc"
25 | #undef STACK
26 | #undef BENCH_TYPE
27 | 
28 | #else
29 | 
30 | #include <benchmark.hpp>
31 | 
32 | using namespace coroutine;
33 | 
34 | namespace BENCH_TYPE {
35 | 
36 | void function(void*) { }
37 | 
38 | BENCH(BENCH_NAME(createContext), 23, BENCH_CAT(createStack, BENCH_TYPE))
39 | {
40 | 	typedef stack::stack<STACK, stack_size> stack_t;
41 | 	typedef context::context<
42 | 	context::resolve_alias<context_tag>::type
43 | 	, stack_t> context_t;
44 | 
45 | 	UNUSED context_t context(&function, 0);
46 | }
47 | 
48 | BENCH(BENCH_NAME(runContext), 23, BENCH_NAME(createContext))
49 | {
50 | 	typedef stack::stack<STACK, stack_size> stack_t;
51 | 	typedef context::context<
52 | 	context::resolve_alias<context_tag>::type
53 | 	, stack_t> context_t;
54 | 
55 | 	UNUSED context_t context(&function, 0);
56 | 	context.enter();
57 | }
58 | 
59 | } // namespace
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/src/coroutine.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 


--------------------------------------------------------------------------------
/benchmarks/include/benchmark.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * benchmark.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef BENCHMARK_H
 9 | #define BENCHMARK_H
10 | 
11 | #include <benchmark/timer.hpp>
12 | #include <list>
13 | #include <functional>
14 | #include <algorithm>
15 | 
16 | namespace benchmark {
17 | 
18 | class Bench;
19 | 
20 | namespace details {
21 | 	
22 | 	std::list<Bench*> benchs;
23 | 
24 | } // namespace details
25 | 
26 | class Bench
27 | {
28 | 	public:
29 | 		Bench() { details::benchs.push_back(this); }
30 | 		virtual ~Bench() {}
31 | 		virtual void do_bench(const char* pkg) const = 0;
32 | };
33 | 
34 | void runalls(const char* pkg)
35 | {
36 | 	std::for_each(details::benchs.begin(), details::benchs.end(),
37 | 			std::bind2nd(std::mem_fun(&Bench::do_bench), pkg));
38 | }
39 | 
40 | } // namespace benchmark
41 | 
42 | #define BENCH_STR(str) #str
43 | #define BENCH_CAT_I(a, b) a##b
44 | #define BENCH_CAT(a, b) BENCH_CAT_I(a, b)
45 | 
46 | #define BENCH(name, cntpower, ...) \
47 | struct BENCH_CAT(bench_, name): benchmark::Bench { \
48 |  \
49 | 	static const char* relatedTo(const char* rt) { return *rt ? rt : "nop"; } \
50 | 	void do_bench(const char* pkg) const { \
51 | 		unsigned cnt = 1u << cntpower; \
52 | 	   	benchmark::Timer t(pkg, BENCH_STR(name), \
53 | 				relatedTo(BENCH_STR(__VA_ARGS__)), cnt);\
54 | 		for (;cnt;cnt--) bench_impl(); }\
55 | 	void bench_impl() const; \
56 | } BENCH_CAT(bench_instance_, name); \
57 | void BENCH_CAT(bench_, name)::bench_impl() const
58 | 
59 | #define BENCH_MAIN(pkg) \
60 | BENCH(nop, 24) {} \
61 | int main() { \
62 | 	benchmark::runalls(#pkg); \
63 | 	return 0; \
64 | }
65 | 
66 | #define UNUSED __attribute__ ((unused))
67 | 
68 | #endif /* BENCHMARK_H */
69 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/arg_max.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_ARG_MAX_HPP_20060728
30 | #  define BOOST_COROUTINE_DETAIL_ARG_MAX_HPP_20060728
31 | #  ifndef BOOST_COROUTINE_ARG_MAX
32 | #    define BOOST_COROUTINE_ARG_MAX 10
33 | #  endif
34 | #endif
35 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_invoke.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/coroutine/coroutine.hpp>
31 | 
32 | namespace coroutines = boost::coroutines;
33 | using coroutines::coroutine;
34 | 
35 | typedef coroutine<void()> coroutine_type;
36 | 
37 | void foo(coroutine_type::self&) {}
38 | 
39 | int main() {
40 |   coroutine_type coro(foo);
41 |   coro();
42 | }
43 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/swap_context.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_SWAP_CONTEXT_HPP_20060611
30 | #define BOOST_COROUTINE_SWAP_CONTEXT_HPP_20060611
31 | namespace boost{ namespace coroutines { namespace detail {
32 |   class default_hint {};
33 |   class yield_hint: public default_hint {};
34 |   class yield_to_hint: public default_hint {};
35 |   class invoke_hint: public default_hint {};
36 |   
37 | } } }
38 | #endif
39 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/build/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | #  Copyright (c) 2006, Giovanni P. Deretta
 2 | #
 3 | #  This code may be used under either of the following two licences:
 4 | #
 5 | #  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | #  of this software and associated documentation files (the "Software"), to deal 
 7 | #  in the Software without restriction, including without limitation the rights 
 8 | #  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | #  copies of the Software, and to permit persons to whom the Software is 
10 | #  furnished to do so, subject to the following conditions:
11 | #
12 | #  The above copyright notice and this permission notice shall be included in 
13 | #  all copies or substantial portions of the Software.
14 | #
15 | #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | #  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | #  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | #  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | #  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | #  THE SOFTWARE. OF SUCH DAMAGE.
22 | #
23 | #  Or:
24 | #
25 | #  Distributed under the Boost Software License, Version 1.0.
26 | #  (See accompanying file LICENSE_1_0.txt or copy at
27 | #  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 
30 | project
31 |   : source-location ../src
32 |   ;
33 | 
34 | import os ;
35 | 
36 | if [ os.name ] = LINUX
37 | {
38 |         TARGET_SPECIFIC_SOURCES =
39 |           swapcontext.cpp
40 | #		coroutine.cpp
41 |           ;
42 | }
43 | 
44 | SOURCES =
45 |         coroutine.cpp
46 |         $(TARGET_SPECIFIC_SOURCES)
47 |         ;
48 | 
49 | lib boost_coroutine
50 |         : $(SOURCES)
51 |         :
52 |         ;
53 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/benchmark/out_of_line.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | /*
30 |  * Out of line definitions for sink and ol_foo.
31 |  * Prototypes in call_overhead.cpp.
32 |  * This functions are on a diferent translation unit to prevent
33 |  * compilers that do unit at a time optimizations to eliminate or inline 
34 |  * them. This won't fool compilers that do whole program optimization though.
35 |  */
36 | void sink(int&) {}
37 | 
38 | void ol_foo(int *x) {
39 |   *x ^=0xAAAA;
40 | }
41 | 


--------------------------------------------------------------------------------
/benchmarks/context_loop.cpp.inc:
--------------------------------------------------------------------------------
 1 | /* vim: ft=cpp
 2 |  * posixContext.cpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #include <coroutine/impl/stack_static.hpp>
 8 | #include <coroutine/impl/stack_dynamic.hpp>
 9 | 
10 | #ifndef BENCH_TYPE
11 | 
12 | #define BENCH_NAME(n) BENCH_CAT(n, BENCH_CAT(BENCH_TYPE, BENCH_CAT(_, BENCH_ARCH)))
13 | 
14 | static const size_t stack_size = 2 * 1024 * 1024;
15 | 
16 | #define BENCH_TYPE _static
17 | #define STACK stack::static_
18 | #include "context_loop.cpp.inc"
19 | #undef STACK
20 | #undef BENCH_TYPE
21 | 
22 | #define BENCH_TYPE _dynamic
23 | #define STACK stack::dynamic
24 | #include "context_loop.cpp.inc"
25 | #undef STACK
26 | #undef BENCH_TYPE
27 | 
28 | #else
29 | 
30 | #include <benchmark.hpp>
31 | 
32 | using namespace coroutine;
33 | 
34 | namespace BENCH_TYPE {
35 | 
36 | void function() { }
37 | 
38 | struct LoopTester
39 | {
40 | 	static const long int LOOP_SIZE = 1 << 14;
41 | 
42 | 	typedef stack::stack<STACK, stack_size> stack_t;
43 | 	typedef context::context<
44 | 	context::resolve_alias<context_tag>::type
45 | 	, stack_t> context_t;
46 | 
47 | 	context_t* context;
48 | 	void setContext(context_t* c) { context = c; }
49 | 
50 | 	void operator()()
51 | 	{
52 | 		for (int i = 0; i < LOOP_SIZE; ++i) {
53 | 			//printf("c %i\n",i);
54 | 			context->leave();
55 | 		}
56 | 	}
57 | 
58 | 	static void dotest(void* self)
59 | 	{
60 | 		(*(LoopTester*)self)();
61 | 	}
62 | };
63 | 
64 | #ifdef BENCH_ARCH_POSIX
65 | #	define RUN_CONTEXT_LOOP_CNT 10
66 | #else
67 | #	define RUN_CONTEXT_LOOP_CNT 14
68 | #endif
69 | 
70 | __attribute__((noinline)) void dothebench()
71 | {
72 | 	LoopTester functor;
73 | 
74 | 	LoopTester::context_t context(&LoopTester::dotest, &functor);
75 | 	functor.setContext(&context);
76 | 
77 | 	for (int i = 0; i < LoopTester::LOOP_SIZE; ++i) {
78 | 		//printf("m %i\n",i);
79 | 		context.enter();
80 | 	}
81 | }
82 | 
83 | BENCH(BENCH_NAME(runContextLoop), RUN_CONTEXT_LOOP_CNT)
84 | {
85 | 	dothebench();
86 | }
87 | 
88 | } // namespace 
89 | 
90 | #endif
91 | 


--------------------------------------------------------------------------------
/include/coroutine/context.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * context.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef CONTEXT_H
 9 | #define CONTEXT_H
10 | 
11 | #include <coroutine/impl/stack_dynamic.hpp>
12 | 
13 | namespace coroutine {
14 | 	namespace context {
15 | 
16 | 		struct context_tag {
17 | 			// context implementation can choose
18 | 			// a different default stack.
19 | 			typedef stack::dynamic default_stack;
20 | 
21 | 
22 | 			/* context implementation HAVE TO define the following template
23 | 			 * to provide a default stack size. This template can the be
24 | 			 * specialized for any stack implementation if needed.
25 | 
26 | 			 template
27 | 			 <typename STACK>
28 | 				struct default_stack_size: stack::size_in_mb<24> {};
29 | 			*/
30 | 		};
31 | 
32 | 		template <typename TAG, class STACK>
33 | 			struct context;
34 | 
35 | 		template <typename T>
36 | 			struct is {
37 | 				static const bool value
38 | 					= details::is_base_of<context_tag, T>::value;
39 | 			};
40 | 
41 | 		namespace details {
42 | 
43 | 			template <typename TAG>
44 | 				struct is_alias_tag {
45 | 					typedef char yes;
46 | 					struct no { yes _[2]; };
47 | 
48 | 					template <typename T>
49 | 						static yes check(T*, typename T::alias* = 0);
50 | 					static no check(...);
51 | 
52 | 					static const bool value
53 | 						= sizeof check((TAG*)0) == sizeof (yes);
54 | 				};
55 | 
56 | 		} // namespace details
57 | 
58 | 		template <typename TAG, bool = details::is_alias_tag<TAG>::value>
59 | 			struct resolve_alias {
60 | 				typedef TAG type;
61 | 			};
62 | 
63 | 		template <typename TAG>
64 | 			struct resolve_alias<TAG, true> {
65 | 				typedef typename
66 | 					resolve_alias<typename TAG::alias>::type
67 | 					type;
68 | 			};
69 | 
70 | 		template <typename T>
71 | 			struct get_args;
72 | 
73 | 		template <typename TAG, typename STACK>
74 | 			struct get_args< context<TAG, STACK> > {
75 | 				typedef TAG   tag_t;
76 | 				typedef STACK stack_t;
77 | 			};
78 | 
79 | 	} // namespace context
80 | } // namespace coroutine
81 | 
82 | #endif /* CONTEXT_H */
83 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/factorial.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/coroutine/coroutine.hpp>
31 | namespace coroutines = boost::coroutines;
32 | using coroutines::coroutine;
33 | 
34 | typedef coroutine<double()> coroutine_type;
35 | size_t factorial(coroutine_type::self& self) {
36 |   double n = 0;
37 |   double n_bang = 1;
38 |   self.yield(n_bang);
39 |   while(true) {
40 |     n_bang = n_bang * ++n;  
41 |     self.yield(n_bang);
42 |   }
43 | }
44 | 
45 | int main() {
46 |   coroutine_type fact(factorial);
47 |   for(int i = 0; i <100; i++)
48 |     std::cout <<i<<"!= "<<fact()<<"\n";
49 | }
50 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/index.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_INDEX_HPP_20060613
30 | #define BOOST_COROUTINE_DETAIL_INDEX_HPP_20060613
31 | #include <boost/preprocessor/repetition.hpp>
32 | #include <boost/coroutine/detail/arg_max.hpp>
33 | namespace boost { namespace coroutines { namespace detail {
34 |   /* 
35 |    * Workaround for BOOST_PP_ENUM_BINARY_PARAMS, where a token
36 |    * can't be createed by appending a number to a '<'.
37 |    * NOTE: we are really abusing BOOST_PP_ENUM_BINARY_PARAMS,
38 |    * Should simply use BOOST_PP_ENUM.
39 |    */
40 |   enum {BOOST_PP_ENUM_PARAMS(BOOST_COROUTINE_ARG_MAX, index_)};
41 | } } }
42 | #endif 
43 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_optional.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/optional.hpp>
31 | #include <boost/coroutine/coroutine.hpp>
32 | namespace coroutines = boost::coroutines;
33 | using coroutines::coroutine;
34 | 
35 | typedef coroutine<boost::optional<int>(int)> coroutine_type;
36 | 
37 | boost::optional<int> coro_body(coroutine_type::self& self, int parm)  {
38 |   self.yield();
39 |   self.yield(0);
40 |   self.yield();
41 |   self.yield(0);
42 |   self.yield();
43 |   self.yield(1);
44 |   return boost::optional<int>();
45 | }
46 | 
47 | int main() {
48 |   coroutine_type coro(coro_body);
49 |   while(coro)
50 |     if(coro())
51 |       std::cout<<"on.\n";
52 |     else
53 |       std::cout<<"off.\n";
54 | }
55 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_yield.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/bind.hpp>
31 | #include <boost/coroutine/coroutine.hpp>
32 | namespace coroutines = boost::coroutines;
33 | using coroutines::coroutine;
34 | 
35 | typedef coroutine<int(int)> coroutine_type;
36 | 
37 | 
38 | 
39 | int coro_body(coroutine_type::self& self, 
40 | 	      int parm) {
41 |   while(parm) {
42 |     std::cout<<"in coroutine, parm: "<<parm<<"\n";
43 |     --parm;
44 |     parm = self.yield(parm); 
45 |   }
46 |   return parm;
47 | }
48 | 
49 | int main() {
50 |   coroutine_type coro(coro_body);
51 | 					
52 |   int  t = 10;
53 |   while(coro) {
54 |     t = coro(t);
55 |     std::cout<<"in main, t: "<<t<<"\n";
56 |   }
57 | }
58 | 
59 | 
60 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/switch_fsm.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <string>
31 | #include <algorithm>
32 | 
33 | // switch based fsm.
34 | struct fsm {
35 | 
36 |   void operator() (char input_) {
37 |     bool input = input_ != '0';
38 |     switch(m_state) {
39 |     case A:
40 |       std::cout << (input? '0' : '0');
41 |       m_state = input? B : A;
42 |       break;
43 |     case B:
44 |       std::cout << (input? '0' : '0');
45 |       m_state = input? C : A;
46 |       break;
47 |     case C:
48 |       std::cout << (input? '0' : '1');
49 |       m_state = input? C : A;
50 |       break;
51 |     };
52 |   }
53 | 
54 |   fsm() :
55 |     m_state(A) {}
56 | 
57 |   enum state { A, B, C };
58 | 
59 |   state m_state;
60 | };
61 | 
62 | int main() {
63 |   std::string input ("0110100010010001101001000111110010011001");
64 |   std::for_each(input.begin(), input.end(), fsm());
65 |   std::cout <<"\n";
66 | }
67 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_yield_to2.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/bind.hpp>
31 | #include <boost/coroutine/coroutine.hpp>
32 | 
33 | namespace coroutines = boost::coroutines;
34 | using coroutines::coroutine;
35 | 
36 | typedef coroutine<int(int)> coroutine_type;
37 | 
38 | coroutine_type coro[2];
39 | 
40 | int coro_body(coroutine_type::self& self, int parm, int id) {
41 |   while(parm) {
42 |     int next = id==0?1:0;
43 |     std::cout<<"in coroutine "<<id<<", parm: "<<parm <<", next: " <<next<<"\n";
44 |     --parm;
45 |     parm = self.yield_to(coro[next], parm); //_to(coro[id]) ; //(coro[id == 1? 0:1], parm);
46 |   }
47 |   return parm;
48 | }
49 | 
50 | int main() {
51 |   coro[0] = coroutine_type(boost::bind(coro_body, _1, _2, 0));
52 |   coro[1] = coroutine_type(boost::bind(coro_body, _1, _2, 1));
53 |   int  t = 10;
54 |   while(coro[0]) {
55 |     t = coro[0](t);
56 |     std::cout << "in main, t: " << t << "\n";
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/yield_result_type.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_YIELD_RESULT_TYPE_HPP_20060609
30 | #define BOOST_COROUTINE_DETAIL_YIELD_RESULT_TYPE_HPP_20060609
31 | #include <boost/coroutine/detail/make_tuple_traits.hpp>
32 | #include <boost/mpl/vector.hpp>
33 | namespace boost{ namespace coroutines { namespace detail {
34 |     /**
35 |      * Same as make_tuple_traits, but if
36 |      * @p TypeList is singular, @p type is the single element, and
37 |      * if TypeList is empty, @p type is @p void.
38 |      */
39 |     template<typename TypeList>
40 |     struct yield_result_type {
41 |       typedef typename make_tuple_traits<TypeList>::type type;
42 |     };
43 |     
44 |     template<typename T>
45 |     struct yield_result_type <boost::mpl::vector1<T> >{
46 |       typedef T type;
47 |     };
48 |     
49 |     template<>
50 |     struct yield_result_type <boost::mpl::vector0<> >{
51 |       typedef void type;
52 |     };
53 | } } }
54 | #endif
55 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/consumer_producer_b.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <cstdlib>
30 | #include <iostream>
31 | #include <algorithm>
32 | #include <string>
33 | #include <boost/bind.hpp>
34 | #include <boost/coroutine/coroutine.hpp>
35 | 
36 | // Producer driven producer/consumer pattern.
37 | namespace coroutines = boost::coroutines;
38 | using coroutines::coroutine;
39 | 
40 | typedef coroutine<void(const std::string&)> coroutine_type;
41 | 
42 | template<typename Consumer>
43 | void producer(Consumer consumer, std::string base) {
44 |   std::sort(base.begin(), base.end());
45 |   do {
46 |     consumer(base);
47 |   } while (std::next_permutation(base.begin(), base.end()));
48 | }
49 | 
50 | void consumer(coroutine_type::self& self, const std::string& value) {
51 |   std::cout << value << "\n";
52 |   while(true) {
53 |     std::cout << self.yield()<< "\n";
54 |   } 
55 | }
56 | 
57 | int main() {
58 |   producer(coroutine_type(consumer),
59 | 	   std::string("hello"));
60 | 
61 |   
62 | }
63 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/doc/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | #  Copyright (c) 2006, Giovanni P. Deretta
 2 | #
 3 | #  This code may be used under either of the following two licences:
 4 | #
 5 | #  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | #  of this software and associated documentation files (the "Software"), to deal 
 7 | #  in the Software without restriction, including without limitation the rights 
 8 | #  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | #  copies of the Software, and to permit persons to whom the Software is 
10 | #  furnished to do so, subject to the following conditions:
11 | #
12 | #  The above copyright notice and this permission notice shall be included in 
13 | #  all copies or substantial portions of the Software.
14 | #
15 | #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | #  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | #  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | #  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | #  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | #  THE SOFTWARE. OF SUCH DAMAGE.
22 | #
23 | #  Or:
24 | #
25 | #  Distributed under the Boost Software License, Version 1.0.
26 | #  (See accompanying file LICENSE_1_0.txt or copy at
27 | #  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 
30 | import doxygen ;
31 | import quickbook ;
32 | 
33 | doxygen autodoc
34 |     :
35 | 	[ glob ../../../boost/coroutine/*.hpp ]
36 |     :
37 |  	<doxygen:param>EXTRACT_ALL=YES	
38 |         <doxygen:param>"PREDEFINED=\"BOOST_COROUTINE_DEDUCED_TYPENAME_DEFAULT=typename\" \\
39 |                                    \"BOOST_DEDUCED_TYPENAME=typename\""
40 |         <doxygen:param>HIDE_UNDOC_MEMBERS=NO
41 |         <doxygen:param>EXTRACT_PRIVATE=NO
42 |         <doxygen:param>ENABLE_PREPROCESSING=YES
43 |         <doxygen:param>MACRO_EXPANSION=YES
44 |         <doxygen:param>EXPAND_ONLY_PREDEF=YES
45 |         <doxygen:param>SEARCH_INCLUDES=YES
46 |         <doxygen:param>INCLUDE_PATH=$(BOOST_ROOT)
47 |     ;
48 | 
49 | xml coroutine
50 |     :
51 |         coroutine.qbk
52 |     ;
53 | 
54 | boostbook standalone
55 |     :
56 |         coroutine
57 |     :
58 |         <xsl:param>toc.max.depth=3
59 |         <xsl:param>toc.section.depth=3
60 |         <xsl:param>chunk.section.depth=3
61 |     ;
62 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_yield_to.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/bind.hpp>
31 | #include <boost/coroutine/coroutine.hpp>
32 | 
33 | namespace coroutines = boost::coroutines;
34 | using coroutines::coroutine;
35 | 
36 | struct my_result {};
37 | struct my_parm {};
38 | 
39 | typedef coroutine<my_result(my_parm)> coroutine_type;
40 | 
41 | my_result coro(coroutine_type& other, 
42 | 	       int id,  
43 | 	       coroutine_type::self& self, 
44 | 	       my_parm parm) {
45 |   int i = 10;
46 |   my_result t;
47 |   while(--i) {
48 |     std::cout<<"in coroutine "<<id<<"\n";
49 |     parm = self.yield_to(other, parm);
50 |   }
51 |   return t;
52 | }
53 | 
54 | int main() {
55 |   coroutine_type coro_a; 
56 |   coroutine_type
57 |     coro_b(boost::bind(coro, boost::ref(coro_a), 0, _1,  _2));
58 |   coro_a = coroutine_type(boost::bind(coro, boost::ref(coro_b), 1, _1, _2)); 
59 | 					
60 |   my_parm t;
61 |   while(coro_a) {
62 |     coro_a(t);
63 |     std::cout<<"in main\n";
64 |   }
65 | }
66 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_reference.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <boost/coroutine/coroutine.hpp>
30 | #include <boost/test/unit_test.hpp>
31 | 
32 | //
33 | // Test support for pass by non const reference.
34 | 
35 | namespace coroutines = boost::coroutines;
36 | using coroutines::coroutine;
37 | 
38 | typedef coroutine<int&(int&)> coroutine_type;
39 | 
40 | int& body(coroutine_type::self& self, int& x) {
41 |   BOOST_CHECK(x == 0);
42 |   x++;
43 |   int a = 0;
44 |   int &b = self.yield(a);
45 |   (void)b; // quiet warning.
46 |   BOOST_CHECK(a == 1);
47 |   return x;
48 | }
49 | 
50 | void test_reference() {
51 |   coroutine_type coro(body);
52 |   int a = 0;
53 |   int &b = coro(a);
54 |   BOOST_CHECK(a == 1);
55 |   b++;
56 |   coro(a);
57 | }
58 | 
59 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
60 | {
61 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("reference coroutine test");
62 | 
63 |     test->add(BOOST_TEST_CASE(&test_reference));
64 | 
65 |     return test;
66 | }
67 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_meta.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/mpl/assert.hpp>
31 | #include <boost/coroutine/detail/is_callable.hpp>
32 | 
33 | namespace coroutines = boost::coroutines;
34 | 
35 | struct test_is_function_pointer {
36 |   template<typename T>
37 |   test_is_function_pointer(T) {
38 |     BOOST_MPL_ASSERT((coroutines::detail::is_function_pointer<T>));
39 |   }
40 | };
41 | 
42 | struct test_is_functor {
43 |   template<typename T>
44 |   test_is_functor(T) {
45 |     BOOST_MPL_ASSERT((coroutines::detail::is_functor<T>));
46 |   }
47 | };
48 | 
49 | struct test_is_callable {
50 |   template<typename T>
51 |   test_is_callable(T) {
52 |     BOOST_MPL_ASSERT((coroutines::detail::is_callable<T>));
53 |   }
54 | };
55 | 
56 | void foo() {}
57 | 
58 | struct bar {
59 |   typedef void result_type;
60 | } a_bar;
61 | 
62 | int main() {
63 |   test_is_function_pointer t1 (foo);
64 |   test_is_functor t2 (a_bar);
65 |   test_is_callable t3 (foo);
66 |   test_is_callable t4 (a_bar);
67 | }
68 | 
69 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | #  Copyright (c) 2006, Giovanni P. Deretta
 2 | #
 3 | #  This code may be used under either of the following two licences:
 4 | #
 5 | #  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | #  of this software and associated documentation files (the "Software"), to deal 
 7 | #  in the Software without restriction, including without limitation the rights 
 8 | #  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | #  copies of the Software, and to permit persons to whom the Software is 
10 | #  furnished to do so, subject to the following conditions:
11 | #
12 | #  The above copyright notice and this permission notice shall be included in 
13 | #  all copies or substantial portions of the Software.
14 | #
15 | #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | #  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | #  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | #  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | #  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | #  THE SOFTWARE. OF SUCH DAMAGE.
22 | #
23 | #  Or:
24 | #
25 | #  Distributed under the Boost Software License, Version 1.0.
26 | #  (See accompanying file LICENSE_1_0.txt or copy at
27 | #  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 
30 | # bring in rules for testing
31 | import testing ;
32 | import os ;
33 | 
34 | if [ os.name ] = WINDOWS
35 | {
36 |         TARGET_SPECIFIC_DEFINE =
37 |           "_WIN32_WINNT=0x0400"
38 |           ;
39 | }
40 | 
41 | project
42 |     : requirements
43 |       	<library>/boost/test//boost_unit_test_framework
44 |       	<library>../build//boost_coroutine
45 |       	<link>static
46 | 	<define>"_WIN32_WINNT=0x0400" #$(TARGET_SPECIFIC_DEFINE)
47 |       	<include>../../..
48 |       	<threading>multi
49 |     ;
50 | 
51 | test-suite "coroutine"
52 |     :
53 |       [ run test_any.cpp ]
54 |       [ run test_create.cpp ]
55 |       [ run test_invoke.cpp ]
56 |       [ run test_meta.cpp ]
57 |       [ run test_optional.cpp ]
58 |       [ run test_yield.cpp ]
59 |       [ run test_yield_to.cpp ]
60 |       [ run test_yield_to2.cpp ]
61 |       [ run test_call.cpp ]
62 |       [ run test_move.cpp ]
63 |       [ run test_non_default_constructible.cpp ]
64 |       [ run test_reference.cpp ]
65 |       [ run test_generator.cpp ]
66 |    ;
67 | 
68 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/matcher.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <string>
31 | #include <boost/coroutine/coroutine.hpp>
32 | 
33 | namespace coroutines = boost::coroutines;
34 | using coroutines::coroutine;
35 | 
36 | bool matcher(coroutine<bool(char)>::self& self, char c) { 
37 |   while(true) { 
38 |     if(c == 'h') { 
39 |       c = self.yield(false); 
40 |       if(c == 'e') { 
41 | 	c = self.yield(false); 
42 | 	if(c == 'l') { 
43 | 	  c = self.yield(false); 
44 | 	  if(c == 'l') { 
45 | 	    c = self.yield(false); 
46 | 	    if(c == 'o') { 
47 | 	      c = self.yield(true); 
48 | 	    } continue; 
49 | 	  } else continue; 
50 | 	} else continue; 
51 |       } else continue; 
52 |     } c = self.yield(false); 
53 |   } 
54 | } 
55 | 
56 | int main(int, char**) { 
57 |   coroutine<bool(char)> match(matcher); 
58 |   std::string buffer = "hello to everybody, this is not an hello world program.";
59 |   for(std::string::iterator i = buffer.begin(); 
60 |       i != buffer.end(); 
61 |       ++i) { 
62 |     if(match(*i)) std::cout<< "match\n"; 
63 |   } 
64 | } 
65 |  
66 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/fix_result.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_FIX_RESULT_HPP_20060709
30 | #define BOOST_COROUTINE_DETAIL_FIX_RESULT_HPP_20060709
31 | #include <boost/utility/enable_if.hpp>
32 | namespace boost { namespace coroutines { namespace detail {
33 |     template<typename Traits>
34 |     inline
35 |     void
36 |     fix_result(const typename Traits::as_tuple&, 
37 | 	       typename 
38 | 	       boost::enable_if_c<Traits::length == 0>::type * = 0){}
39 | 
40 | 
41 |     template<typename Traits>
42 |     inline
43 |     typename Traits::template at<0>::type
44 |     fix_result(const typename Traits::as_tuple& x, 
45 | 	       typename 
46 | 	       boost::enable_if_c<Traits::length == 1>::type * = 0){
47 |       using boost::get;
48 |       return get<0>(x);
49 |     }
50 | 
51 | 
52 |     template<typename Traits>
53 |     inline
54 |     typename Traits::as_tuple
55 |     fix_result(const typename Traits::as_tuple& x, 
56 | 	       typename 
57 | 	       boost::enable_if_c<(Traits::length > 1)>::type* =0){
58 |       return x;
59 |     }
60 | } } }
61 | #endif
62 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/noreturn.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_NORETURN_HPP_20060812
30 | #define BOOST_COROUTINE_DETAIL_NORETURN_HPP_20060812
31 | /*
32 |  * The BOOST_COROUTINE_NORETURN macro provides a way to 
33 |  * tell the compiler that a function will not return through
34 |  * the normal return path (it could return throgh a thrown exception).
35 |  * This not only provieds a possible optimization hint, but also
36 |  * prevents the compiler from complaining if a function that call
37 |  * a noreturn function does not call return itself.
38 |  */
39 | #include <boost/config.hpp>
40 | 
41 | #if defined(__GNUC__)
42 | 
43 | #define BOOST_COROUTINE_NORETURN(function) \
44 |     function __attribute__((__noreturn__)) \
45 | /**/
46 |   
47 | #elif defined (BOOST_MSVC)
48 | 
49 | #define BOOST_COROUTINE_NORETURN(function) \
50 |     __declspec(noreturn) function          \
51 | /**/
52 | 
53 | #else
54 | //just for testing, remove the following error.
55 | #error no default
56 | #define BOOST_COROUTINE_NORETURN(function) \
57 |     function
58 | /**/
59 | 
60 | #endif
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/signal.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_SIGNAL_HPP_20060728
30 | #define BOOST_COROUTINE_DETAIL_SIGNAL_HPP_20060728
31 | #include <boost/coroutine/detail/future_impl.hpp>
32 | namespace boost { namespace coroutines { namespace detail {
33 |   /*
34 |    * Private interface for coroutine signaling/waiting.
35 |    * These class is friend of future_impl and
36 |    * its static members are invoked by asynchronous callback functions.
37 |    */
38 |   struct wait_gateway {
39 |     template<typename Future>
40 |     static void wait(Future& f, int n) {
41 |       f.wait(n);
42 |     }
43 | 
44 |     template<typename Future>
45 |     static 
46 |     bool waited(const Future& f) {
47 |       return f.waited();
48 |     }
49 | 
50 |     template<typename Future>
51 |     static 
52 |     void mark_wait(Future& f, bool how) {
53 |       f.mark_wait(how);
54 |     }
55 | 
56 |     template<typename Future>
57 |     static
58 |     BOOST_DEDUCED_TYPENAME 
59 |     Future::impl_pointer
60 |     get_impl(Future& f) {
61 |       return f.m_ptr;
62 |     }
63 |   };
64 | 
65 | 
66 | } } }
67 | #endif
68 | 


--------------------------------------------------------------------------------
/tests/coroutine/exception.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * createCoroutine.cpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #include <test.hpp>
  8 | #include <coroutine/builder.hpp>
  9 | #include <iostream>
 10 | #include <coroutine/impl/context_posix.hpp>
 11 | #include <coroutine/stack.hpp>
 12 | 
 13 | #include <typeinfo>
 14 | 
 15 | using namespace coroutine;
 16 | 
 17 | void f_trow_int(yielder<void ()>)
 18 | {
 19 | 	std::cout << "I am gonna throw an int!!!" << std::endl;
 20 | 	throw 42;
 21 | }
 22 | 
 23 | BOOST_AUTO_TEST_CASE(throw_int)
 24 | {
 25 | 	auto c = corof(&f_trow_int);
 26 | 
 27 | 	std::cout << "before call" << std::endl;
 28 | 	BOOST_REQUIRE_THROW( c(), int );
 29 | 	std::cout << "after call " << std::endl;
 30 | }
 31 | 
 32 | BOOST_AUTO_TEST_CASE(throw_already_terminated_with_throw)
 33 | {
 34 | 	auto c = corof(&f_trow_int);
 35 | 
 36 | 	std::cout << "before call" << std::endl;
 37 | 	BOOST_REQUIRE_THROW( c(), int );
 38 | 	std::cout << "after call " << std::endl;
 39 | 	BOOST_REQUIRE_THROW( c(), std::runtime_error );
 40 | }
 41 | 
 42 | void f_nothing(yielder<void ()>)
 43 | {
 44 | 	std::cout << "Hi from a coroutine" << std::endl;
 45 | }
 46 | 
 47 | BOOST_AUTO_TEST_CASE(throw_already_terminated)
 48 | {
 49 | 	auto c = corof(&f_nothing);
 50 | 
 51 | 	c();
 52 | 	BOOST_REQUIRE_THROW( c(), std::runtime_error );
 53 | }
 54 | 
 55 | int f_little_loop(yielder<int ()> yield)
 56 | {
 57 | 	int next = 0;
 58 | 	int end = 25;
 59 | 	while (true) {
 60 | 		auto v = next;
 61 | 		++next;
 62 | 		if (next == end)
 63 | 			return v;
 64 | 		yield(v);
 65 | 	}
 66 | }
 67 | 
 68 | BOOST_AUTO_TEST_CASE(check_loop_and_stop)
 69 | {
 70 | 	auto c = corof(&f_little_loop);
 71 | 
 72 | 	for (int i = 0; i < 25; ++i)
 73 | 		BOOST_CHECK(c() == i);
 74 | 	BOOST_REQUIRE_THROW( c(), std::runtime_error );
 75 | }
 76 | 
 77 | BOOST_AUTO_TEST_CASE(check_terminated_status)
 78 | {
 79 | 	auto c = corof(&f_little_loop);
 80 | 
 81 | 	int i = 0;
 82 | 	while (c)
 83 | 		BOOST_CHECK(c() == i++);
 84 | 	BOOST_REQUIRE_THROW( c(), std::runtime_error );
 85 | }
 86 | 
 87 | BOOST_AUTO_TEST_CASE(check_closure)
 88 | {
 89 | 	int v = 21;
 90 | 	auto c = coro<int ()>([=] (yielder<int ()> yield) {
 91 | 			yield(v - 11);
 92 | 			return v * 2;
 93 | 			});
 94 | 
 95 | 	BOOST_CHECK( c() == 10 );
 96 | 	BOOST_CHECK( c() == 42 );
 97 | 	BOOST_REQUIRE_THROW( c(), std::runtime_error );
 98 | }
 99 | 
100 | struct Toto {};
101 | 
102 | BOOST_AUTO_TEST_CASE(check_type)
103 | {
104 | 	const std::type_info& t = typeid(int (Toto));
105 | 	std::cout << (
106 | 			typeid(int (Toto)) == t
107 | 			)	<< std::endl;
108 | }
109 | 


--------------------------------------------------------------------------------
/include/coroutine/stack.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * stack.hpp
 3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
 4 |  *
 5 | */
 6 | 
 7 | #pragma once
 8 | #ifndef STACK_H
 9 | #define STACK_H
10 | 
11 | namespace coroutine {
12 | 	namespace details {
13 | 
14 | 		template <typename B, typename D>
15 | 			struct is_base_of {
16 | 				typedef char yes;
17 | 				struct no { yes _[2]; };
18 | 
19 | 				static yes check(B*);
20 | 				static no check(...);
21 | 
22 | 				static const bool value
23 | 					= sizeof check((D*)0) == sizeof (yes);
24 | 			};
25 | 
26 | 	} // namespace details
27 | 
28 | 	namespace stack {
29 | 
30 | 		struct size_tag {};
31 | 
32 | 		template <size_t V>
33 | 			struct size_in_b: size_tag {
34 | 				static const size_t value = V;
35 | 			};
36 | 
37 | 		template <size_t V>
38 | 			struct size_in_kb: size_tag {
39 | 				static const size_t value = V * 1024;
40 | 			};
41 | 
42 | 		template <size_t V>
43 | 			struct size_in_mb: size_tag {
44 | 				static const size_t value = V * 1024 * 1024;
45 | 			};
46 | 
47 | 		template <typename T>
48 | 			struct is_size {
49 | 				static const bool value
50 | 					= details::is_base_of<size_tag, T>::value;
51 | 			};
52 | 
53 | 		struct stack_tag {
54 | 			// Technically, stack object have to be moveable to allow retuning
55 | 			// coroutine from function, using a nice coroutine builder and so
56 | 			// on. However, at soon as the coroutine is started the stack
57 | 			// CANNOT move because some code is using it. An exception will be
58 | 			// threw if you try to move an already running one. However, if a
59 | 			// stack is allocated dynamically, it's possible to move the object
60 | 			// encapsulating it while keeping the same physical stack. For any
61 | 			// stack that can be really moved, set this attribute to true to
62 | 			// access the liberty of free moving running coroutines.
63 | 			static const bool really_moveable = false;
64 | 		};
65 | 
66 | 		template <typename TAG, size_t SSIZE>
67 | 			class stack;
68 | 
69 | 		template <typename T>
70 | 			struct is {
71 | 				static const bool value
72 | 					= details::is_base_of<stack_tag, T>::value;
73 | 			};
74 | 
75 | 		namespace details {
76 | 
77 | 			template <typename T>
78 | 				struct get_tag;
79 | 
80 | 			template <typename TAG, size_t SSIZE>
81 | 				struct get_tag< stack<TAG, SSIZE> > {
82 | 					typedef TAG type;
83 | 				};
84 | 
85 | 		} // namespace details
86 | 
87 | 		template <typename T>
88 | 			struct is_really_moveable {
89 | 				static const bool value
90 | 					= details::get_tag<T>::type::really_moveable;
91 | 			};
92 | 
93 | 	} // namespace stack
94 | } // namespace coroutine
95 | 
96 | #endif /* STACK_H */
97 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/is_callable.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_IS_CALLABLE_HPP_20060601
30 | #define BOOST_COROUTINE_DETAIL_IS_CALLABLE_HPP_20060601
31 | #include <boost/utility/enable_if.hpp>
32 | #include <boost/type_traits.hpp>
33 | #include <boost/mpl/logical.hpp>
34 | #include <boost/mpl/has_xxx.hpp>
35 | namespace boost { namespace coroutines { namespace detail {
36 |   template<typename T>
37 |   struct is_function_pointer : 
38 |     boost::mpl::and_<
39 |     boost::is_pointer<T>,
40 |     boost::is_function<typename boost::remove_pointer<T>::type > > {
41 |     typedef is_function_pointer<T> type;
42 |   };
43 | 
44 |   BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type);
45 |   BOOST_MPL_HAS_XXX_TRAIT_DEF(result);
46 |   
47 |   template<typename T>
48 |   struct is_functor : 
49 |     boost::mpl::or_<typename has_result_type<T>::type,
50 | 		    typename has_result<T>::type>
51 |   {
52 |     typedef is_functor<T> type;
53 |   };
54 | 
55 |   template<typename T>
56 |   struct is_callable : boost::mpl::or_<
57 |     is_functor<T>,
58 |     is_function_pointer<T> >::type {
59 |     typedef is_callable<T> type;
60 |   };
61 | } } }
62 | #endif
63 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_non_default_constructible.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <boost/coroutine/coroutine.hpp>
30 | #include <boost/test/unit_test.hpp>
31 | 
32 | namespace coroutines = boost::coroutines;
33 | using coroutines::coroutine;
34 | 
35 | //
36 | // Test coroutine capability to handle non default constructible
37 | // types both as result type and as arguments.
38 | 
39 | class ndc {
40 | public:
41 |   explicit 
42 |   ndc(int) {}
43 | 
44 |   ndc(const ndc&) {}
45 | 
46 |   ndc& operator=(const ndc&) {
47 |     return *this;
48 |   }
49 | private:
50 | };
51 | 
52 | typedef coroutine<ndc(ndc)> coroutine_type;
53 | 
54 | ndc body(coroutine_type::self& self, ndc x) {
55 |   self.yield(x);  
56 |   self.yield(x);  
57 |   return ndc (0);
58 | }
59 | 
60 | void test_ndc() {
61 |   coroutine_type coro(body);
62 |   ndc result (coro(ndc(0)));
63 |   result = (coro(result));
64 | }
65 | 
66 | 
67 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
68 | {
69 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("non-default-constructible-types coroutine test");
70 | 
71 |     test->add(BOOST_TEST_CASE(&test_ndc));
72 | 
73 |     return test;
74 | }
75 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/signature.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_SIGNATURE_HPP_20060609
30 | #define BOOST_COROUTINE_DETAIL_SIGNATURE_HPP_20060609
31 | #include <boost/preprocessor/repetition.hpp>
32 | #include <boost/coroutine/detail/arg_max.hpp>
33 | namespace boost{ namespace coroutines{ namespace detail{
34 |   /*
35 |    * Derived from an  mpl::vector describing
36 |    * 'Function' arguments types.
37 |    */
38 |   template<typename Function>
39 |   struct signature;
40 | 
41 |   /*
42 |    * Generate specializations for the signature trait class.
43 |    */
44 | #define BOOST_COROUTINE_SIGNATURE_GENERATOR(z, n, unused)        \
45 |   template <class R BOOST_PP_ENUM_TRAILING_PARAMS(n, class A)>   \
46 |   struct signature<R( BOOST_PP_ENUM_PARAMS(n,A) ) >              \
47 |     : boost::mpl::BOOST_PP_CAT(vector,n)<                        \
48 |     BOOST_PP_ENUM_PARAMS(n,A)                                    \
49 |     > {};                                                        \
50 | /**/
51 | 
52 |   
53 |   BOOST_PP_REPEAT(BOOST_COROUTINE_ARG_MAX, BOOST_COROUTINE_SIGNATURE_GENERATOR, ~);
54 | #undef BOOST_COROUTINE_SIGNATURE_GENERATOR
55 | } } }
56 | #endif
57 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/scheduler.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <string>
31 | #include <boost/coroutine/shared_coroutine.hpp>
32 | #include <boost/bind.hpp>
33 | #include<queue>
34 | 
35 | namespace coro = boost::coroutines;
36 | using coro::shared_coroutine;
37 | 
38 | typedef shared_coroutine<void()> job_type;
39 | 
40 | class scheduler {
41 | public:
42 |   void add(job_type job) {
43 |     m_queue.push(job);
44 |   }
45 |   
46 |   job_type& current() {
47 |     return m_queue.front();
48 |   }
49 | 
50 |   void run () {
51 |     while(!m_queue.empty()) {
52 |       current()(std::nothrow);
53 |       if(current()) 
54 | 	add(current());
55 |       m_queue.pop();
56 |     }
57 |   }
58 | private:
59 | 
60 |   std::queue<job_type> m_queue;
61 | };
62 | 
63 | scheduler global_scheduler;
64 | 
65 | void printer(job_type::self& self, std::string name, int iterations) {
66 |   while(iterations --) {
67 |     std::cout<<name <<" is running, "<<iterations<<" iterations left\n";
68 |     self.yield();
69 |   }
70 |   self.exit();
71 | }
72 | 
73 | int main() {
74 |   global_scheduler.add(boost::bind(printer, _1, "first", 10));
75 |   global_scheduler.add(boost::bind(printer, _1, "second", 5));
76 |   global_scheduler.add(boost::bind(printer, _1, "third", 3));
77 |   global_scheduler.run();
78 | }
79 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_any.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/assert.hpp>
31 | #include <boost/any.hpp>
32 | #include <boost/test/unit_test.hpp>
33 | #include <boost/coroutine/coroutine.hpp>
34 | 
35 | namespace coroutines = boost::coroutines;
36 | using coroutines::coroutine;
37 | 
38 | typedef coroutine<boost::any()> coroutine_type;
39 | 
40 | struct first_type{};
41 | struct second_type{};
42 | struct third_type{};
43 | struct fourth_type{};
44 | struct fifth_type{};
45 | 
46 | boost::any coro_body(coroutine_type::self& self)  {
47 |   self.yield(first_type());
48 |   self.yield(second_type());
49 |   self.yield(third_type());
50 |   self.yield(fourth_type());
51 |   return fifth_type();  
52 | }
53 | 
54 | void test_any() {
55 |   coroutine_type coro(coro_body);
56 |   BOOST_CHECK(coro().type() == typeid(first_type));
57 |   BOOST_CHECK(coro().type() == typeid(second_type));
58 |   BOOST_CHECK(coro().type() == typeid(third_type));
59 |   BOOST_CHECK(coro().type() == typeid(fourth_type));
60 |   BOOST_CHECK(coro().type() == typeid(fifth_type));
61 | }
62 | 
63 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
64 | {
65 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("any coroutine test");
66 | 
67 |     test->add(BOOST_TEST_CASE(&test_any));
68 | 
69 |     return test;
70 | }
71 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/Jamfile.v2:
--------------------------------------------------------------------------------
 1 | #  Copyright (c) 2006, Giovanni P. Deretta
 2 | #
 3 | #  This code may be used under either of the following two licences:
 4 | #
 5 | #  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | #  of this software and associated documentation files (the "Software"), to deal 
 7 | #  in the Software without restriction, including without limitation the rights 
 8 | #  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | #  copies of the Software, and to permit persons to whom the Software is 
10 | #  furnished to do so, subject to the following conditions:
11 | #
12 | #  The above copyright notice and this permission notice shall be included in 
13 | #  all copies or substantial portions of the Software.
14 | #
15 | #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | #  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | #  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | #  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | #  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | #  THE SOFTWARE. OF SUCH DAMAGE.
22 | #
23 | #  Or:
24 | #
25 | #  Distributed under the Boost Software License, Version 1.0.
26 | #  (See accompanying file LICENSE_1_0.txt or copy at
27 | #  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 
30 | # bring in rules for testing
31 | import os ;
32 | 
33 | if [ os.name ] = WINDOWS
34 | {
35 |         TARGET_SPECIFIC_DEFINE =
36 |           "_WIN32_WINNT=0x0400"
37 |           ;
38 | }
39 | 
40 | project
41 |     : requirements
42 |       	<library>/boost/test//boost_unit_test_framework
43 |       	<library>../build//boost_coroutine
44 |       	<link>static
45 | 	<define>"_WIN32_WINNT=0x0400" #$(TARGET_SPECIFIC_DEFINE)
46 |       	<include>../../..
47 |       	<threading>multi
48 | 
49 |     ;
50 | 
51 | exe factorial : factorial.cpp ;
52 | exe prisonerdilemma : prisonerdilemma.cpp ;
53 | exe banana : banana.cpp ;
54 | exe matcher : matcher.cpp ;
55 | exe samefringe : samefringe.cpp ;
56 | exe samefringe2 : samefringe2.cpp ;
57 | exe token_passing : token_passing.cpp : <cflags>-march=pentium4 ;
58 | exe token_passing_baseline : token_passing_baseline.cpp : <cflags>-march=pentium4 ;
59 | exe complex_matcher : complex_matcher.cpp ;
60 | exe scheduler : scheduler.cpp ;
61 | exe scheduler_wait : scheduler_wait.cpp ;
62 | exe consumer_producer_a : consumer_producer_a.cpp ;
63 | exe consumer_producer_b : consumer_producer_b.cpp ;
64 | exe consumer_producer_c : consumer_producer_c.cpp ;
65 | exe switch_fsm : switch_fsm.cpp ;
66 | exe coroutine_fsm : coroutine_fsm.cpp ;
67 | exe coroutine_fsm_regexp : coroutine_fsm_regexp.cpp ;
68 | 


--------------------------------------------------------------------------------
/tests/context/oslinuxABIcheck.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * oslinuxABIcheck.cpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #include <test.hpp>
  8 | #include <coroutine/impl/context_linux.hpp>
  9 | 
 10 | using namespace coroutine;
 11 | 
 12 | static const size_t stack_size = 8 * 1024 * 1024;
 13 | typedef stack::stack<stack::dynamic, stack_size> stack_t;
 14 | typedef context::context<
 15 | 	context::resolve_alias<context::linux>::type
 16 | 	, stack_t> context_t;
 17 | 
 18 | template <size_t ARCH_SIZE>
 19 | struct ABIConsistencyCheck;
 20 | 
 21 | template <>
 22 | struct ABIConsistencyCheck<8>
 23 | {
 24 | 	static void check()
 25 | 	{
 26 | 		asm (
 27 | 				"push $42\n\t"
 28 | 				"mov $0x42, %%rax\n\t"
 29 | 				"mov $0x43, %%rbx\n\t"
 30 | 				"mov $0x44, %%rcx\n\t"
 31 | 				"mov $0x45, %%rdx\n\t"
 32 | 				"mov $0x46, %%r8\n\t"
 33 | 				"mov $0x47, %%r9\n\t"
 34 | 				"mov $0x48, %%r10\n\t"
 35 | 				"mov $0x49, %%r11\n\t"
 36 | 				"mov $0x4a, %%r12\n\t"
 37 | 				"mov $0x4b, %%r13\n\t"
 38 | 				"mov $0x4c, %%r14\n\t"
 39 | 				"mov $0x4d, %%r15\n\t"
 40 | 				"mov $0x4e, %%rsi\n\t"
 41 | 				"mov $0x4f, %%rdi\n\t"
 42 | 				"pop %%rax\n\t"
 43 | 				: // output
 44 | 				// not used
 45 | 				: // input
 46 | 				// not used
 47 | 				: // modified
 48 | 				"rax", "rbx", "rcx", "rdx", "rdi", "rsi",
 49 | 				"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
 50 | 				);
 51 | 	}
 52 | };
 53 | 
 54 | template <>
 55 | struct ABIConsistencyCheck<4>
 56 | {
 57 | 	static void check()
 58 | 	{
 59 | 		asm (
 60 | 				"push $42\n\t"
 61 | 				"mov $0x42, %%eax\n\t"
 62 | 				"mov $0x43, %%ebx\n\t"
 63 | 				"mov $0x44, %%ecx\n\t"
 64 | 				"mov $0x45, %%edx\n\t"
 65 | 				"mov $0x4e, %%esi\n\t"
 66 | 				"mov $0x4f, %%edi\n\t"
 67 | 				"mov $0x50, %%ebp\n\t"
 68 | 				"pop %%eax\n\t"
 69 | 				: // output
 70 | 				// not used
 71 | 				: // input
 72 | 				// not used
 73 | 				: // modified
 74 | 				"eax", "ebx", "ecx", "edx", "edi", "esi", "ebp"
 75 | 				);
 76 | 	}
 77 | };
 78 | 
 79 | struct TestExecution
 80 | {
 81 | 	bool executed;
 82 | 	TestExecution(): executed(false) { }
 83 | 	virtual void operator()() { executed = true; }
 84 | 
 85 | 	static void dotest(void* te) {
 86 | 		(*(TestExecution*)(te))();
 87 | 	}
 88 | };
 89 | 
 90 | template <typename Context>
 91 | struct TestYield: TestExecution
 92 | {
 93 |     Context context;
 94 | 	TestYield(): context(&TestYield::dotest, this) {}
 95 | 	void operator()()
 96 | 	{
 97 | 		TestExecution::operator()();
 98 | 		ABIConsistencyCheck<sizeof (void*)>::check();
 99 | 		context.leave();
100 | 		BOOST_ERROR("yield passed");
101 | 	}
102 | };
103 | 
104 | BOOST_AUTO_TEST_CASE(checkABIconsistency)
105 | {
106 | 	for (int i = 0; i < 500; ++i)
107 | 	{
108 | 		TestYield<context_t> test;
109 | 		test.context.enter();
110 | 		BOOST_CHECK(test.executed);
111 | 	}
112 | }
113 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_move.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <boost/coroutine/coroutine.hpp>
31 | #include <boost/coroutine/move.hpp>
32 | #include <boost/test/unit_test.hpp>
33 | 
34 | namespace coroutines = boost::coroutines;
35 | using coroutines::coroutine;
36 | 
37 | typedef coroutine<void(void)> coroutine_type;
38 | 
39 | void coroutine_body(coroutine_type::self&) {}
40 | 
41 | void sink(coroutine_type) {}
42 | 
43 | coroutine_type source() {
44 |   return coroutine_type(coroutine_body);
45 | }
46 | 
47 | void sink_ref(boost::coroutines::move_from<coroutine_type>){}
48 | 
49 | void test_move() {
50 |   std::cout << "test 1\n";
51 |   coroutine_type coro (source());
52 |   std::cout << "test 2\n";
53 |   coroutine_type coro2 = coroutine_type(coroutine_body);
54 |   std::cout << "test 3\n";
55 |   coroutine_type coro3;
56 |   std::cout << "test 4\n";
57 |   coro3 = coroutine_type(coroutine_body);
58 |   std::cout << "test 5\n";
59 |   coroutine_type coro4 = source();
60 |   std::cout << "test 6\n";
61 |   coroutine_type coro5 (source());
62 |   std::cout << "test 7\n";
63 |   sink(coroutine_type(coroutine_body));
64 |   std::cout << "test 8\n";
65 |   sink(move(coro5));
66 |   std::cout << "test 9\n";
67 |   coro3 = move(coro4);
68 |   std::cout << "test 10\n";
69 |   sink(source());
70 | 
71 | }
72 | 
73 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
74 | {
75 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("move coroutine test");
76 | 
77 |     test->add(BOOST_TEST_CASE(&test_move));
78 | 
79 |     return test;
80 | }
81 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/coroutine_fsm_regexp.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <string>
31 | #include <algorithm>
32 | #include <boost/coroutine/shared_coroutine.hpp>
33 | 
34 | namespace coroutines = boost::coroutines;
35 | using coroutines::shared_coroutine;
36 | 
37 | typedef shared_coroutine<void(char)> coroutine_type;
38 | 
39 | void fsm_regexp(coroutine_type::self& self, char) {
40 |   while(true) {
41 |     if(self.result() == '0') {
42 |       std::cout << '0';
43 |       self.yield();
44 |       if(self.result() == '1') {
45 | 	std::cout << '0';
46 | 	self.yield();
47 | 	while(self.result() == '1') {
48 | 	  std::cout << '0';
49 | 	  self.yield();
50 | 	}
51 | 	std::cout <<'0';
52 | 	self.yield();
53 | 	if(self.result() == '1') {
54 | 	  std::cout << '0';
55 | 	  self.yield();
56 | 	  if(self.result() == '0') {
57 | 	    std::cout << '1';
58 | 	    self.yield();
59 | 	  } else {
60 | 	    std::cout <<'0';
61 | 	    self.yield();
62 | 	  }
63 | 	} else {
64 | 	  std::cout <<'0';
65 | 	  self.yield();
66 | 	}
67 |       } else {
68 | 	std::cout << '0';
69 | 	self.yield();
70 |       }
71 |     } else {
72 |       std::cout <<'0';
73 |       self.yield();
74 |     }
75 |   } 
76 | }
77 | 
78 | int main() {
79 |   {
80 |     std::string input ("0110100010010001101001000111110010011001");
81 |     std::for_each(input.begin(), input.end(), coroutine_type(fsm_regexp));
82 |     std::cout <<"\n";
83 |   }
84 |   {
85 |     std::string input ("011011010");
86 |     std::for_each(input.begin(), input.end(), coroutine_type(fsm_regexp));
87 |     std::cout <<"\n";
88 |   }
89 | 
90 | }
91 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_generator.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <vector>
30 | #include <iterator>
31 | #include <algorithm>
32 | #include <boost/bind.hpp>
33 | #include <boost/coroutine/generator.hpp>
34 | #include <boost/test/unit_test.hpp>
35 | 
36 | namespace coroutines = boost::coroutines;
37 | using coroutines::generator;
38 | 
39 | typedef generator<int> generator_type;
40 | 
41 | int count(generator_type::self& self, int rmin, int rmax) {
42 |   while(rmin < rmax -1) {
43 |     self.yield(rmin++);
44 |   }
45 |   return (rmin);
46 | }
47 | 
48 | int count2(generator_type::self& self, int rmin, int rmax) {
49 |   while(rmin < rmax) {
50 |     self.yield(rmin++);
51 |   }
52 |   self.exit();
53 | }
54 | 
55 | 
56 | void test_generator() {
57 |   {
58 |     generator_type gen(boost::bind(count, _1, 10, 20));
59 |     std::vector<int> vec;
60 |     std::copy(gen, generator_type(), std::back_inserter(vec));
61 |     BOOST_CHECK(vec.size() == 10);
62 |   }
63 |   {
64 |     generator_type gen(boost::bind(count2, _1, 10, 20));
65 |     std::vector<int> vec;
66 |     std::copy(gen, generator_type(), std::back_inserter(vec));
67 |     BOOST_CHECK(vec.size() == 10);
68 |   }
69 |   {
70 |     generator_type gen(boost::bind(count2, _1, 10, 20));
71 |     std::vector<int> vec;
72 |     std::copy(gen, generator_type(), std::back_inserter(vec));
73 |     BOOST_CHECK(vec.size() == 10);
74 |   }
75 | 
76 | }
77 | 
78 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
79 | {
80 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("generator test");
81 | 
82 |     test->add(BOOST_TEST_CASE(&test_generator));
83 | 
84 |     return test;
85 | }
86 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/src/swapcontext.s:
--------------------------------------------------------------------------------
  1 | //  (C) Copyright Giovanni P. Deretta 2005. 
  2 | //  Distributed under the Boost Software License, Version 1.0. 
  3 | //  (See accompanying file LICENSE_1_0.txt or copy at 
  4 | //  http://www.boost.org/LICENSE_1_0.txt)
  5 |   .global swapcontext_stack,	
  6 |   .type swapcontext_stack, @function
  7 |   .align 1<<4	
  8 | /* 
  9 | 	EAX is &from.sp	
 10 | 	EDX is to.sp
 11 | 	This is the simplest version of swapcontext
 12 | 	It saves registers on the old stack,
 13 | 	saves the old stack pointer, 
 14 | 	load the new stack pointer,
 15 | 	pop registers from the new stack
 16 | 	 and returns to new caller.
 17 | 	EAX is simpy passed to the function it returns to.
 18 | 	The first time EAX is the first parameter of the trampoline.
 19 | 	Otherwise it is simply discarded.
 20 | 	NOTE: This function should work on any IA32 CPU.
 21 | 	NOTE: The biggest penality is the last jump that
 22 | 	will be always mispredicted (~50 cycles on P4).
 23 | 	We try to make its address available as soon as possible
 24 | 	to try to reduce the penality. Doing a ret instead of a 
 25 | 	'add $4, %esp'
 26 | 	'jmp *%ecx'
 27 | 	really kills performance.
 28 | 	NOTE: popl is slightly better than mov+add to pop registers
 29 | 	so is pushl rather than mov+sub.
 30 |    */
 31 | 
 32 | swapcontext_stack:
 33 | 	movl  16(%edx), %ecx	
 34 | 	pushl %ebp	
 35 | 	pushl %ebx	
 36 | 	pushl %esi	
 37 | 	pushl %edi	
 38 | 	movl  %esp, (%eax)
 39 | 	movl  %edx, %esp
 40 | 	popl  %edi	
 41 | 	popl  %esi	
 42 | 	popl  %ebx		
 43 | 	popl  %ebp
 44 | 	add   $4, %esp
 45 | //	popl %ecx
 46 | 	jmp   *%ecx
 47 | 	ud2	
 48 |   .global swapcontext_stack2,	
 49 |   .type swapcontext_stack2, @function
 50 |   .align 1<<4
 51 | 	
 52 | /*
 53 |   This is exactly the same than swapcontext_stack,
 54 |   but while the swapcontext_stack should be used
 55 |   for invocations, this should be used for yielding,
 56 |   thus there are two 'jmp' sites that, in the common
 57 |   invoke+yield case, each jump always to the same target
 58 |   and can be predicted (this is very important on P4).
 59 |   This optimization gives a 50% performance bonus on a plain
 60 |   'invoke and yield' test.
 61 |   NOTE:	 both subroutines work even if they are used in the
 62 |    wrong place. 
 63 |  */	
 64 | swapcontext_stack2:
 65 | 	movl  16(%edx), %ecx	
 66 | 	pushl %ebp	
 67 | 	pushl %ebx	
 68 | 	pushl %esi	
 69 | 	pushl %edi	
 70 | 	movl  %esp, (%eax)
 71 | 	movl  %edx, %esp
 72 | 	popl  %edi	
 73 | 	popl  %esi	
 74 | 	popl  %ebx		
 75 | 	popl  %ebp
 76 | 	add   $4, %esp
 77 | //	popl %ecx
 78 | 	jmp   *%ecx
 79 | 	ud2
 80 | 
 81 | swapcontext_stack3:
 82 | 	movl  16(%edx), %ecx	
 83 | 	pushl %ebp	
 84 | 	pushl %ebx	
 85 | 	pushl %esi	
 86 | 	pushl %edi	
 87 | 	movl  %esp, (%eax)
 88 | 	movl  %edx, %esp
 89 | 	popl  %edi	
 90 | 	popl  %esi	
 91 | 	popl  %ebx		
 92 | 	popl  %ebp
 93 | 	add   $4, %esp
 94 | //	popl  %ecx
 95 | 	jmp   *%ecx
 96 | 	ud2
 97 | 
 98 | swapcontext_stack_orig:
 99 | 	pushl %ebp	
100 | 	pushl %ebx	
101 | 	pushl %esi	
102 | 	pushl %edi	
103 | 	movl  %esp, (%eax)
104 | 	movl  %edx, %esp
105 | 	popl  %edi	
106 | 	popl  %esi	
107 | 	popl  %ebx		
108 | 	popl  %ebp
109 | 	ret
110 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/consumer_producer_a.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <cstdlib>
30 | #include <iostream>
31 | #include <algorithm>
32 | #include <string>
33 | #include <boost/bind.hpp>
34 | #include <boost/coroutine/generator.hpp>
35 | 
36 | // Consumer driven producer/consumer pattern.
37 | namespace coroutines = boost::coroutines;
38 | using coroutines::generator;
39 | 
40 | typedef generator<const std::string&> generator_type;
41 | 
42 | const std::string& producer(generator_type::self& self, std::string base) {
43 |   std::sort(base.begin(), base.end());
44 |   do {
45 |     self.yield(base);
46 |   } while (std::next_permutation(base.begin(), base.end()));
47 |   self.exit();
48 | }
49 | 
50 | template<typename Producer>
51 | void consumer(Producer producer) {
52 |   do {
53 |     std::cout <<*producer << "\n";
54 |   } while(++producer);
55 | }
56 | 
57 | struct filter {
58 |   typedef const std::string& result_type;
59 | 
60 |   template<typename Producer>
61 |   const std::string& operator()
62 |     (generator_type::self& self, Producer producer) {
63 |     do {
64 |       self.yield(*producer + " world");
65 |     } while(++producer);
66 | 
67 |     self.exit();
68 |     // gcc complains here while it doesn't for `producer`... werid.
69 |     // the abort quiets it.
70 |     abort();
71 |     // it doesn't quiet VCPP8 though!
72 |   }
73 | };
74 | int main() {
75 |   consumer
76 |     (generator_type
77 |      (boost::bind
78 |       (producer, _1, std::string("hello"))));
79 | 
80 |   
81 |   consumer
82 |     (generator_type
83 |      (boost::bind
84 |       (filter(),
85 |        _1,
86 |        generator_type
87 |        (boost::bind
88 | 	(producer, _1, std::string("hello"))))));
89 |   
90 | }
91 | 


--------------------------------------------------------------------------------
/include/coroutine/impl/context_posix.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * context_posix.hpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #pragma once
  8 | #ifndef CONTEXT_POSIX_H
  9 | #define CONTEXT_POSIX_H
 10 | 
 11 | #include <stdexcept>
 12 | #include <string.h>
 13 | #include <errno.h>
 14 | #include <coroutine/context.hpp>
 15 | #include <coroutine/impl/stack_static.hpp>
 16 | 
 17 | namespace coroutine {
 18 | 	namespace context {
 19 | 
 20 | 		struct posix: context_tag {
 21 | 			template <typename STACK>
 22 | 				struct default_stack_size: stack::size_in_mb<64> {};
 23 | 		};
 24 | 
 25 | 		template <>
 26 | 			struct posix::default_stack_size<stack::static_>
 27 | 			: stack::size_in_mb<8> {};
 28 | 
 29 | 		namespace posix_api {
 30 | #				include <ucontext.h>
 31 | 		} // namespace posix_api
 32 | 
 33 | 		template <class STACK>
 34 | 			struct context<posix, STACK> {
 35 | 				typedef STACK stack_t;
 36 | 				public:
 37 | 					typedef void (function_t)(void*);
 38 | 
 39 | 					context(function_t* f, void* arg):
 40 | 						_f(f), _arg(arg) { reset(); }
 41 | 
 42 | 					context(const context& from) = delete;
 43 | 					context& operator=(const context& from) = delete;
 44 | 					context& operator=(context&& from) = delete;
 45 | 
 46 | 					context(context&& from):
 47 | 						_maincontext(from._maincontext),
 48 | 						_corocontext(from._corocontext),
 49 | 						_f(from._f),
 50 | 						_arg(from._arg),
 51 | 						_stack(std::move(from._stack))
 52 | 					{
 53 | 						_corocontext.uc_link = &_maincontext;
 54 | 						from._maincontext.uc_stack.ss_sp = 0;
 55 | 						from._corocontext.uc_stack.ss_sp = 0;
 56 | 						from._f = 0;
 57 | 						from._arg = 0;
 58 | 					}
 59 | 
 60 | 					void reset()
 61 | 					{
 62 | 						if (getcontext(&_corocontext) == -1)
 63 | 							error(__PRETTY_FUNCTION__, "getcontext failed");
 64 | 						_corocontext.uc_link = &_maincontext;
 65 | 						_corocontext.uc_stack.ss_sp = _stack.get_stack_ptr();
 66 | 						_corocontext.uc_stack.ss_size = _stack.get_size();
 67 | 						makecontext(&_corocontext, (void (*)()) _f, 1, _arg);
 68 | 					}
 69 | 
 70 | 					void enter()
 71 | 					{
 72 | 						if (swapcontext(&_maincontext, &_corocontext) == -1)
 73 | 							error(__PRETTY_FUNCTION__, "swapcontext failed");
 74 | 					}
 75 | 
 76 | 					void leave()
 77 | 					{
 78 | 						if (swapcontext(&_corocontext, &_maincontext) == -1)
 79 | 							error(__PRETTY_FUNCTION__, "swapcontext failed");
 80 | 					}
 81 | 
 82 | 					static const char* get_impl_name() { return "posix"; }
 83 | 
 84 | 				private:
 85 | 					posix_api::ucontext _maincontext;
 86 | 					posix_api::ucontext _corocontext;
 87 | 					function_t* _f;
 88 | 					void*       _arg;
 89 | 					stack_t     _stack;
 90 | 
 91 | 					void error(const char* fname, const char* msg)
 92 | 					{
 93 | 						char buf[256];
 94 | 						std::string errmsg
 95 | 							= std::string(fname) + ": " + msg + ", ";
 96 | 
 97 | 						if (::strerror_r(errno, buf, sizeof buf) == 0)
 98 | 							errmsg += buf;
 99 | 						else
100 | 							errmsg += "unknown error";
101 | 
102 | 						throw std::runtime_error(errmsg);
103 | 					}
104 | 			};
105 | 
106 | 	} // namespace context
107 | } // namespace coroutine
108 | 
109 | #endif /* CONTEXT_POSIX_H */
110 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/has_swap.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 
30 | // Copyright David Abrahams 2004. Distributed under the Boost
31 | // Software License, Version 1.0. (See accompanying
32 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
33 | // 
34 | // Slightly modified for inclusion on coroutines/detail library.
35 | #ifndef BOOST_COROUTINE_DETAIL_HAS_SWAP_HPP_20060709
36 | #define BOOST_COROUTINE_DETAIL_HAS_SWAP_HPP_20060709
37 | 
38 | #include <boost/mpl/bool.hpp>
39 | #include <boost/detail/workaround.hpp>
40 | 
41 | namespace boost { namespace coroutines {
42 | 
43 | 
44 | namespace has_swap_
45 | {
46 |   // any soaks up implicit conversions and makes the following
47 |   // operator++ less-preferred than any other such operator which
48 |   // might be found via ADL.
49 |   struct anything { template <class T> anything(T const&); };
50 |   struct no_swap
51 |   {
52 |       char (& operator,(char) )[2];
53 |   };
54 |   no_swap swap(anything,anything);
55 |     
56 | #if defined(BOOST_MSVC)
57 | # pragma warning(push)
58 | # pragma warning(disable: 4675) // function found through argument dependent lookup -- duh!
59 | #endif 
60 |   template <class T>
61 |   struct has_swap_impl
62 |   {
63 |       static T& x;
64 |         
65 |       BOOST_STATIC_CONSTANT(bool, value = sizeof(swap(x,x),'x') == 1);
66 |       
67 | #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
68 |       typedef boost::mpl::bool_<has_swap_impl<T>::value> type;
69 | #else
70 |       typedef boost::mpl::bool_<value> type;
71 | #endif      
72 |   };
73 | }
74 | template <class T>
75 | struct has_swap
76 |   : has_swap_::has_swap_impl<T>::type
77 | {};
78 | #if defined(BOOST_MSVC)
79 | # pragma warning(pop)
80 | #endif 
81 | 
82 | } } 
83 | 
84 | #endif // include guard
85 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/make_tuple_traits.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_MAKE_TUPLE_TRAITS_HPP_20060609
30 | #define BOOST_COROUTINE_DETAIL_MAKE_TUPLE_TRAITS_HPP_20060609
31 | #include <boost/preprocessor/repetition.hpp>
32 | #include <boost/mpl/vector.hpp>
33 | #include <boost/coroutine/detail/arg_max.hpp>
34 | #include <boost/coroutine/tuple_traits.hpp>
35 | 
36 | namespace boost { namespace coroutines { namespace detail {
37 |   /*
38 |    * Given a mpl::vector, returns a nullary metafunction
39 |    * describing a tuple of all types in the vector.
40 |    * NOTE this is just wrong because it should work for all mpl
41 |    * sequences, not just vectors. But it is in detail, so leave it
42 |    * as is. Eventually it will be replaced by Boost.Fusion.
43 |    * @p type is a tuple of all types in TypeList.
44 |    * TypeList is one of mpl::vector0, mpl::vector1, etc.
45 |    */
46 |   template<typename TypeList>
47 |   struct make_tuple_traits;
48 | 
49 | #define BOOST_COROUTINE_MAKE_TUPLE_TRAITS_GENERATOR(z, n, unused)       \
50 |     template<BOOST_PP_ENUM_PARAMS(n, class A)>                   \
51 |     struct make_tuple_traits<BOOST_PP_CAT(boost::mpl::vector, n)        \
52 |         <BOOST_PP_ENUM_PARAMS(n, A)> >{                          \
53 |         typedef tuple_traits<BOOST_PP_ENUM_PARAMS(n, A)> type;   \
54 |     };                                                           \
55 | /**/
56 | 
57 |   /**
58 |    * Generate specializations of make_tuple
59 |    * @note This could be done more elegantly with a recursive metafunction, 
60 |    * but this is simpler and works well anyway.
61 |    */
62 |   BOOST_PP_REPEAT(BOOST_COROUTINE_ARG_MAX, 
63 | 		  BOOST_COROUTINE_MAKE_TUPLE_TRAITS_GENERATOR, ~);
64 | #undef BOOST_COROUTINE_MAKE_TUPLE_TRAITS_GENERATOR
65 | 
66 | } } }
67 | #endif 
68 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/shared_coroutine.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_SHARED_COROUTINE_HPP_20060812
30 | #define BOOST_COROUTINE_SHARED_COROUTINE_HPP_20060812
31 | #include <boost/coroutine/coroutine.hpp>
32 | namespace boost { namespace coroutines {
33 |   // This class is a workaround for the widespread lack of move
34 |   // semantics support. It is a refrence counted wrapper around 
35 |   // the coroutine object.
36 |   // FIXME: ATM a shared_coroutine is-a coroutine. This is to avoid
37 |   // inheriting privately and cluttering the code with lots of using
38 |   // declarations to unhide coroutine members and nested types.
39 |   // From a purity point of view, coroutines and shared_coroutines should
40 |   // be two different types.
41 |   template<typename Signature, typename ContextImpl = detail::default_context_impl> 
42 |   class shared_coroutine : public coroutine<Signature, ContextImpl> {
43 |   public:
44 |     typedef coroutine<Signature, ContextImpl> coroutine_type;
45 | 
46 |     shared_coroutine() {}
47 | 
48 |     template<typename Functor>
49 |     shared_coroutine(Functor f, 
50 | 		     std::ptrdiff_t stack_size = 
51 | 		     detail::default_stack_size) :
52 |       coroutine_type(f, stack_size) {}
53 | 
54 |     shared_coroutine(move_from<coroutine_type> src):
55 |       coroutine_type(src) {}
56 | 
57 |     shared_coroutine(const shared_coroutine& rhs) :
58 |       coroutine_type(rhs.m_pimpl.get(), detail::init_from_impl_tag()) {}
59 | 
60 |     shared_coroutine& operator=(move_from<coroutine_type> src) {
61 |       shared_coroutine(src).swap(*this);
62 |       return *this;
63 |     }
64 | 
65 |     shared_coroutine& operator=(const shared_coroutine& rhs) {
66 |       shared_coroutine(rhs).swap(*this);
67 |       return *this;
68 |     }    
69 |   private:
70 |   };
71 | } }
72 | #endif
73 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/banana.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #include <iostream>
30 | #include <string>
31 | #include <boost/bind.hpp>
32 | #include <boost/coroutine/coroutine.hpp>
33 | 
34 | namespace coroutines = boost::coroutines;
35 | using coroutines::coroutine;
36 | 
37 | template<typename Iter>
38 | bool match(Iter first, Iter last, std::string match) {
39 |   std::string::iterator i = match.begin();
40 |   i != match.end();
41 |   for(; (first != last) && (i != match.end()); ++i) {
42 |     if (*first != *i)
43 |       return false;
44 |     ++first;
45 |   }
46 |   return i == match.end();
47 | }
48 | 
49 | template<typename BidirectionalIterator> 
50 | BidirectionalIterator 
51 | match_substring(BidirectionalIterator begin, 
52 | 		BidirectionalIterator end, 
53 | 		std::string xmatch,
54 | 		BOOST_DEDUCED_TYPENAME coroutine<BidirectionalIterator(void)>::self& self) { 
55 |   BidirectionalIterator begin_ = begin;
56 |   for(; begin != end; ++begin) 
57 |     if(match(begin, end, xmatch)) {
58 |       self.yield(begin);
59 |     }
60 |   return end;
61 | } 
62 | 
63 | typedef coroutine<std::string::iterator(void)> coroutine_type;
64 | int main(int, char**) { 
65 |   std::string buffer = "banananana"; 
66 |   std::string match = "nana"; 
67 |   std::string::iterator begin = buffer.begin();
68 |   std::string::iterator end = buffer.end();
69 | 
70 |   typedef std::string::iterator signature(std::string::iterator, 
71 | 					  std::string::iterator, 
72 | 					  std::string,
73 | 					  coroutine_type::self&);
74 | 
75 |   coroutine<std::string::iterator(void)> matcher
76 |       (boost::bind(static_cast<signature*>(match_substring), 
77 | 		   begin, 
78 | 		   end, 
79 | 		   match, 
80 | 		   _1)); 
81 | 
82 |   std::string::iterator i = matcher();
83 |   while(matcher && i != buffer.end()) {
84 |     std::cout <<"Match at: "<< std::distance(buffer.begin(), i)<<'\n'; 
85 |     i = matcher();
86 |   }
87 | } 
88 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/exception.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_EXCEPTION_HPP_20060601
30 | #define BOOST_COROUTINE_EXCEPTION_HPP_20060601
31 | #include <exception>
32 | #include <typeinfo>
33 | namespace boost { namespace coroutines {
34 | 
35 |   // All coroutine exceptions are derived from this base.
36 |   class exception_base : public std::exception {};
37 | 
38 |   // This exception is thrown when a coroutine is requested
39 |   // to exit.
40 |   class exit_exception:  public exception_base {};
41 | 
42 |   // This exception is thrown on a coroutine invocation
43 |   // if a coroutine exits without
44 |   // returning a result. Note that calling invoke()
45 |   // on an already exited coroutine is undefined behaviour.
46 |   class coroutine_exited: public exception_base {};  
47 |   
48 |   // This exception is thrown on a coroutine invocation
49 |   // if a coroutine enter the wait state without
50 |   // returning a result. Note that calling invoke()
51 |   // on a waiting coroutine is undefined behaviour.
52 |   class waiting : public exception_base {};
53 | 
54 |   class unknown_exception_tag {};
55 | 
56 |   // This exception is thrown on a coroutine invocation
57 |   // if the coroutine is exited by an uncatched exception
58 |   // (not derived from exit_exception). abnormal_exit::type()
59 |   // returns the typeid of that exception if it is derived
60 |   // from std::exception, else returns typeid(unknonw_exception_tag)
61 |   class abnormal_exit : public std::exception {
62 |   public:
63 |     abnormal_exit(std::type_info const& e) :
64 |       m_e (e) {};
65 | 
66 |     const char* what() const throw() {
67 |       return m_e == typeid(unknown_exception_tag)? 
68 | 	"unknown exception" :
69 | 	m_e.name();
70 |     }
71 | 
72 |     std::type_info const& type() const throw() {
73 |       return m_e;
74 |     }
75 |   private:
76 |     std::type_info const& m_e;
77 |   };
78 | } } 
79 | 
80 | #endif
81 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/coroutine_traits.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_DETAIL_COROUTINE_TRAITS_HPP_20060613
30 | #define BOOST_COROUTINE_DETAIL_COROUTINE_TRAITS_HPP_20060613
31 | #include <boost/type_traits.hpp>
32 | #include <boost/coroutine/tuple_traits.hpp>
33 | #include <boost/coroutine/detail/yield_result_type.hpp>
34 | 
35 | namespace boost { namespace coroutines { namespace detail {
36 | 
37 |   template<typename T>
38 |   struct as_tuple {
39 |     typedef typename T::as_tuple type;
40 |   };
41 | 
42 |   // This trait class is used to compute
43 |   // all nested typedefs of coroutines given
44 |   // a signature in the form 'result_type(parm1, ... parmn)'.
45 |   template<typename Signature>
46 |   struct coroutine_traits {    
47 |   private:
48 | 
49 |     typedef BOOST_DEDUCED_TYPENAME boost::function_traits<Signature>::result_type 
50 |     signature_result_type;
51 |   public:
52 |     typedef BOOST_DEDUCED_TYPENAME
53 |     boost::mpl::eval_if<is_tuple_traits<signature_result_type>,
54 | 			as_tuple<signature_result_type>,
55 | 			boost::mpl::identity<signature_result_type> >
56 |     ::type result_type;
57 | 
58 |     typedef BOOST_DEDUCED_TYPENAME
59 |     boost::mpl::eval_if<is_tuple_traits<signature_result_type>,
60 | 			boost::mpl::identity<signature_result_type>,
61 | 			boost::mpl::if_
62 | 			<boost::is_same<signature_result_type, void>,
63 | 			 tuple_traits<>,
64 | 			 tuple_traits<signature_result_type> > >
65 |     ::type result_slot_traits;
66 |     
67 |     typedef BOOST_DEDUCED_TYPENAME result_slot_traits
68 |     ::as_tuple result_slot_type;
69 |     	     
70 |     typedef BOOST_DEDUCED_TYPENAME detail::make_tuple_traits
71 |     <typename detail::signature<Signature>::type >
72 |     ::type arg_slot_traits;
73 | 
74 |     typedef BOOST_DEDUCED_TYPENAME arg_slot_traits
75 |     ::as_tuple arg_slot_type;
76 | 
77 |     typedef BOOST_DEDUCED_TYPENAME arg_slot_traits
78 |     ::as_result yield_result_type;
79 | 
80 |   };
81 | } } }
82 | #endif
83 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/consumer_producer_c.cpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #include <cstdlib>
 30 | #include <iostream>
 31 | #include <string>
 32 | #include <algorithm>
 33 | #include <boost/bind.hpp>
 34 | #include <boost/coroutine/coroutine.hpp>
 35 | 
 36 | // peers version of the producer/consumer pattern.
 37 | namespace coroutines = boost::coroutines;
 38 | using coroutines::coroutine;
 39 | 
 40 | typedef coroutine<void(const std::string&)> consumer_type;
 41 | typedef coroutine<void()> producer_type;
 42 | 
 43 | void producer_body(producer_type::self& self, 
 44 | 		   std::string base, 
 45 | 		   consumer_type& consumer) {
 46 |   std::sort(base.begin(), base.end());
 47 |   do {
 48 |     self.yield_to(consumer, base);
 49 |   } while (std::next_permutation(base.begin(), base.end()));
 50 | }
 51 | 
 52 | void consumer_body(consumer_type::self& self, 
 53 | 		   const std::string& value,
 54 | 		   producer_type& producer) {
 55 |   std::cout << value << "\n";
 56 |   while(true) {
 57 |     std::cout << self.yield_to(producer) << "\n";
 58 |   } 
 59 | }
 60 | 
 61 | int main() {
 62 |   {
 63 |     std::string test("test");
 64 |     std::cout << test;
 65 | 
 66 |     producer_type producer;
 67 |     consumer_type consumer;
 68 |     
 69 |     producer = producer_type
 70 |       (boost::bind
 71 |        (producer_body, 
 72 | 	_1, 
 73 | 	"hello", 
 74 | 	boost::ref(consumer)));
 75 | 
 76 |     consumer = consumer_type
 77 |       (boost::bind
 78 |        (consumer_body, 
 79 | 	_1,
 80 | 	_2,
 81 | 	boost::ref(producer)));
 82 |        
 83 |     producer();
 84 |   }
 85 | 
 86 |   {
 87 |     producer_type producer;
 88 |     consumer_type consumer;
 89 |     
 90 |     consumer = consumer_type
 91 |       (boost::bind
 92 |        (consumer_body, 
 93 | 	_1,
 94 | 	_2,
 95 | 	boost::ref(producer)));
 96 |        
 97 |     producer = producer_type
 98 |       (boost::bind
 99 |        (producer_body, 
100 | 	_1, 
101 | 	"hello", 
102 | 	boost::ref(consumer)));
103 |        
104 |     consumer(std::string());
105 |   }  
106 | }
107 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/coroutine_accessor.hpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #ifndef BOOST_COROUTINE_DETAIL_COROUTINE_ACCESSOR_HPP_20060709
 30 | #define BOOST_COROUTINE_DETAIL_COROUTINE_ACCESSOR_HPP_20060709
 31 | #include  <boost/utility/in_place_factory.hpp>
 32 | namespace boost { namespace coroutines { namespace detail {
 33 |   
 34 |   /*
 35 |    * This is a private interface used for coroutine
 36 |    * implementation.
 37 |    */
 38 |   struct init_from_impl_tag{};
 39 |   struct coroutine_accessor {
 40 | 
 41 |     // Initialize coroutine from implementation type.
 42 |     // used by the in_place_assing in place factory.
 43 |     template<typename Coroutine, typename Ctx>
 44 |     static
 45 |     void construct(Ctx * src, void * address) {
 46 |       new (address) Coroutine(src, init_from_impl_tag());
 47 |     }
 48 | 
 49 |     template<typename Coroutine>
 50 |     static 
 51 |     void acquire(Coroutine& x) {
 52 |       x.acquire();
 53 |     }
 54 | 
 55 |     template<typename Coroutine>
 56 |     static
 57 |     void release(Coroutine& x) {
 58 |       x.release();
 59 |     }
 60 | 
 61 |     template<typename Ctx>
 62 |     struct in_place_assign : boost::in_place_factory_base {
 63 | 
 64 |       in_place_assign(Ctx * ctx) :
 65 | 	m_ctx(ctx) {}
 66 | 
 67 |       template<typename Coroutine>
 68 |       void apply(void * memory) const {
 69 | 	construct<Coroutine>(m_ctx, memory);
 70 |       }
 71 |       Ctx * m_ctx;
 72 |     };
 73 | 
 74 |     template<typename Ctx>
 75 |     static 
 76 |     in_place_assign<Ctx>
 77 |     in_place(Ctx * ctx) {
 78 |       return in_place_assign<Ctx>(ctx);
 79 |     }
 80 | 
 81 |     template<typename Coroutine>
 82 |     static
 83 |     typename Coroutine::impl_ptr
 84 |     get_impl(Coroutine& x) {
 85 |       return x.get_impl();
 86 |     }
 87 | 
 88 |     template<typename Coroutine>
 89 |     static
 90 |     typename Coroutine::impl_type *
 91 |     pilfer_impl(Coroutine& x) {
 92 |       return x.pilfer_impl();
 93 |     }
 94 | 
 95 |     template<typename Coroutine>
 96 |     static
 97 |     std::size_t
 98 |     count(const Coroutine& x) {
 99 |       return x.count();
100 |     }
101 |   };
102 | } } }
103 | #endif
104 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/argument_packer.hpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | #ifndef BOOST_COROUTINE_ARGUMENT_PACKER_HPP_20060601
30 | #define BOOST_COROUTINE_ARGUMENT_PACKER_HPP_20060601
31 | #include <boost/preprocessor/control/if.hpp>
32 | #include <boost/preprocessor/punctuation/comma_if.hpp>
33 | #include <boost/preprocessor/repetition.hpp>
34 | #include <boost/preprocessor/tuple/eat.hpp>
35 | 
36 | namespace boost { namespace coroutines { namespace detail {
37 | #define BOOST_COROUTINE_DETAIL_TEMPLATE_PARAMETERS(n)  \
38 |   template<BOOST_PP_ENUM_PARAMS(n, typename T)> \
39 | /**/
40 | 
41 | #define BOOST_COROUTINE_ARGUMENT_PACKER(z, n, parm_tuple)        \
42 |   BOOST_PP_IF(n,                                                 \
43 | 	      BOOST_COROUTINE_DETAIL_TEMPLATE_PARAMETERS ,              \
44 | 	      BOOST_PP_TUPLE_EAT(1) )(n)                         \
45 |   BOOST_PP_TUPLE_ELEM(3, 0, parm_tuple)                          \
46 |     (BOOST_PP_ENUM_BINARY_PARAMS(n, T, arg)) {                   \
47 |     typedef BOOST_PP_TUPLE_ELEM(3, 2, parm_tuple) parm_type;     \
48 |     return BOOST_PP_TUPLE_ELEM(3, 1, parm_tuple)                 \
49 |                              (parm_type                          \
50 | 			      (BOOST_PP_ENUM_PARAMS(n, arg)));   \
51 |   }                                                              \
52 | /**/
53 | 
54 | 
55 | #define BOOST_COROUTINE_ARGUMENT_PACKER_EX(z, n, parm_tuple)     \
56 |   template<typename Arg                                          \
57 |     BOOST_PP_COMMA_IF(n)                                         \
58 |     BOOST_PP_ENUM_PARAMS(n, typename T)>                         \
59 |   BOOST_PP_TUPLE_ELEM(3, 0, parm_tuple)                          \
60 |   (Arg arg                                                       \
61 |    BOOST_PP_COMMA_IF(n)                                          \
62 |    BOOST_PP_ENUM_BINARY_PARAMS(n, T, arg)) {                     \
63 |     typedef BOOST_PP_TUPLE_ELEM(3, 2, parm_tuple) parm_type;     \
64 |     return BOOST_PP_TUPLE_ELEM(3, 1, parm_tuple)( arg, parm_type \
65 |      (BOOST_PP_ENUM_PARAMS(n, arg)));                            \
66 |   }                                                              \
67 | /**/
68 | 
69 | } } }
70 | #endif
71 | 


--------------------------------------------------------------------------------
/benchmarks/stats.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | import sys
  4 | import pprint
  5 | import matplotlib.pyplot as plt
  6 | import numpy as np
  7 | import math
  8 | 
  9 | pp = pprint.pprint
 10 | 
 11 | if len(sys.argv) != 2:
 12 | 	print 'usage: %s logfile' % (sys.argv[0])
 13 | 	exit(1)
 14 | logpath = sys.argv[1]
 15 | 
 16 | def stripunit(dic, key):
 17 | 	dic[key] = dic[key].strip('nsec')
 18 | 
 19 | print "Loading %s..." % (logpath)
 20 | 
 21 | pkgs = {}
 22 | fd = open(logpath, 'r')
 23 | for line in fd:
 24 | 	keyvals = [kv.strip().split('=') for kv in line.strip().split(',')]
 25 | 	record = {}
 26 | 	for kv in keyvals:
 27 | 		record[kv[0]] = kv[1]
 28 | 	stripunit(record, 'elapsed')
 29 | 	stripunit(record, 'res')
 30 | 	pkg = record['pkg']
 31 | 	del record['pkg']
 32 | 	del record['res']
 33 | 	record['elapsed'] = float(record['elapsed']) / float(record['cnt'])
 34 | 	del record['cnt']
 35 | 	if pkg in pkgs:
 36 | 		pkgs[pkg].append(record)
 37 | 	else:
 38 | 		pkgs[pkg] = [record]
 39 | fd.close()
 40 | 
 41 | for pkg, records in pkgs.items():
 42 | 	print "Sorting %s benchmarks..." % (pkg)
 43 | 	pkg_sum = {}
 44 | 	for record in records:
 45 | 		name = record['name']
 46 | 		del record['name']
 47 | 		if name in pkg_sum:
 48 | 			pkg_sum[name].append(record)
 49 | 		else:
 50 | 			pkg_sum[name] = [record]
 51 | 	pkgs[pkg] = pkg_sum
 52 | 
 53 | for pkg, records in pkgs.items():
 54 | 	print "Computing average time for %s benchmarks..." % (pkg)
 55 | 	for name, record in records.items():
 56 | 		relto = record[0]['relto']
 57 | 		elapsed = int(sum([r['elapsed'] for r in record]) / len(record))
 58 | 		records[name] = { 'elapsed': elapsed, 'relto': relto }
 59 | 
 60 | def remove_rel_time(records, key):
 61 | 	if 'relto' not in records[key]:
 62 | 		return
 63 | 	relto = records[key]['relto']
 64 | 	#del records[key]['relto']
 65 | 	if key == relto:
 66 | 		records[key]['elapsed_abs'] = records[key]['elapsed']
 67 | 		return
 68 | 
 69 | 	if relto in records:
 70 | 		remove_rel_time(records, relto)
 71 | 		rel_records = records
 72 | 	else:
 73 | 		for p_name, p_records in pkgs.items():
 74 | 			if relto in p_records:
 75 | 				remove_rel_time(p_records, relto)
 76 | 				rel_records = p_records
 77 | 				break
 78 | 
 79 | 	records[key]['elapsed_abs'] = int(records[key]['elapsed']
 80 | 			- rel_records[relto]['elapsed'])
 81 | 
 82 | for pkg, records in pkgs.items():
 83 | 	print "Removing relative time for %s benchmarks..." % (pkg)
 84 | 	for name, record in records.items():
 85 | 		print name, record
 86 | 		remove_rel_time(records, name)
 87 | 
 88 | def computeSubplotColAndRow(nbsubfig):
 89 | 	size = int(math.sqrt(nbsubfig - 1)) + 1
 90 | 	nbrow = size
 91 | 	nbcol = size
 92 | 	empty = (nbrow * nbcol) - nbsubfig
 93 | 	if empty >= size:
 94 | 		nbcol -= (empty / size)
 95 | 	return (nbrow, nbcol)
 96 | 
 97 | subrow, subcol = computeSubplotColAndRow(len(pkgs))
 98 | subIdx = 1
 99 | 
100 | colors = ('b', 'g', 'y', 'r')
101 | colorIdx = 0
102 | 
103 | plt.suptitle(logpath)
104 | 
105 | for pkg, records in pkgs.items():
106 | 	print "Plotting %s benchmarks..." % (pkg)
107 | 
108 | 	records_keys = sorted(records.keys())
109 | 
110 | 	plt.subplot(subrow * 100 + subcol * 10 + subIdx)
111 | 	pos = np.arange(len(records))+.5
112 | 	plt.barh(pos, [records[k]['elapsed'] for k in records_keys],
113 | 			align='center', color='y', alpha=0.15,
114 | 			label='total elapsed time')
115 | 
116 | 	plt.barh(pos, [records[k]['elapsed_abs'] for k in records_keys],
117 | 			align='center', color='b', alpha=0.75,
118 | 			label='absolute elapsed time')
119 | 
120 | 	plt.yticks(pos, records_keys)
121 | 
122 | 	plt.xlabel('time in nanoseconds, shorter is better')
123 | 
124 | 	plt.legend();
125 | 	colorIdx += 1
126 | 	subIdx += 1
127 | 
128 | print "Rendering..."
129 | plt.show()
130 | 


--------------------------------------------------------------------------------
/include/coroutine/yielder.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * yielder.hpp
  3 |  * Copyright © 2011, François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #pragma once
  8 | #ifndef YIELDER_H
  9 | #define YIELDER_H
 10 | 
 11 | #include <iostream>
 12 | 
 13 | /*
 14 |  * TODO
 15 |  *
 16 |  * yield of type yielder is used like that:
 17 |  *
 18 |  * feed_val = yield(ret_val);
 19 |  *
 20 |  * It's should possible to provide overload with move semantic.
 21 |  * It's maybe overkill because: each side (main code/coroutine code)
 22 |  * need to know if the value was yield/feed from an RVALUE
 23 |  * to be able to pass it on the other side as an RVALUE too.
 24 |  * Adding a simple boolean and a if could do the trick, but I feel
 25 |  * it will be slower than simply allowing only copy semantic.
 26 |  * After all, if you need to pass value without duplicating it (thats
 27 |  * the main purpose of move semantic), simply yield/feed a pointer.
 28 |  */
 29 | 
 30 | namespace coroutine {
 31 | 
 32 | 	/*
 33 | 	 * FV stand for Feed Value, the value feeded to the coroutine for each
 34 | 	 * iteration.
 35 | 	 * RV stand for Return Value, the value returned by the coroutine for
 36 | 	 * each iteration.
 37 | 	 */
 38 | 
 39 | 	namespace details {
 40 | 
 41 | 		template <typename RV, typename FV>
 42 | 			struct cb_type { typedef FV (*type)(void*, RV); };
 43 | 
 44 | 		template <typename FV>
 45 | 			struct cb_type<void, FV> { typedef FV (*type)(void*); };
 46 | 
 47 | 	} // namespace details
 48 | 
 49 | 	template <typename RV, typename FV>
 50 | 		class yielder_base
 51 | 		{
 52 | 		public:
 53 | 			typedef typename details::cb_type<RV, FV>::type cb_t;
 54 | 
 55 | 			yielder_base(const yielder_base& from):
 56 | 				_cb(from._cb), _ptr(from._ptr) {
 57 | 				}
 58 | 
 59 | 		protected:
 60 | 			cb_t  _cb;
 61 | 			void* _ptr;
 62 | 
 63 | 			yielder_base(cb_t cb, void* ptr):
 64 | 				_cb(cb), _ptr(ptr) {
 65 | 				}
 66 | 
 67 | 		private:
 68 | 			yielder_base& operator=(const yielder_base& from); // disabled
 69 | 		};
 70 | 
 71 | 	template <typename S = void ()>
 72 | 		class yielder;
 73 | 
 74 | 	// RV f(FV feedValue)
 75 | 	template <typename RV, typename FV>
 76 | 		class yielder<RV (FV)>: public yielder_base<RV, FV>
 77 | 	{
 78 | 		typedef yielder_base<RV, FV>  base_t;
 79 | 		typedef typename base_t::cb_t cb_t;
 80 | 
 81 | 		public:
 82 | 		FV operator()(RV value) const {
 83 | 			return this->_cb(this->_ptr, value);
 84 | 		}
 85 | 
 86 | 		yielder(cb_t cb, void* ptr): base_t(cb, ptr) { }
 87 | 	};
 88 | 
 89 | 	// RV f()
 90 | 	template <typename RV>
 91 | 		class yielder<RV ()>: public yielder_base<RV, void>
 92 | 		{
 93 | 			typedef yielder_base<RV, void> base_t;
 94 | 			typedef typename base_t::cb_t cb_t;
 95 | 
 96 | 			public:
 97 | 			void operator()(RV value) const {
 98 | 				this->_cb(this->_ptr, value);
 99 | 			}
100 | 
101 | 			yielder(cb_t cb, void* ptr): base_t(cb, ptr) { }
102 | 		};
103 | 
104 | 	// void f(FV feedValue)
105 | 	template <typename FV>
106 | 		class yielder<void (FV)>: public yielder_base<void, FV>
107 | 		{
108 | 			typedef yielder_base<void, FV> base_t;
109 | 			typedef typename base_t::cb_t cb_t;
110 | 
111 | 			public:
112 | 			FV operator()() const {
113 | 				return this->_cb(this->_ptr);
114 | 			}
115 | 
116 | 			yielder(cb_t cb, void* ptr): base_t(cb, ptr) { }
117 | 		};
118 | 
119 | 	// void f()
120 | 	template <>
121 | 		class yielder<void ()>: public yielder_base<void, void>
122 | 		{
123 | 			typedef yielder_base<void, void> base_t;
124 | 			typedef typename base_t::cb_t   cb_t;
125 | 
126 | 			public:
127 | 			void operator()() const {
128 | 				this->_cb(this->_ptr);
129 | 			}
130 | 
131 | 			yielder(cb_t cb, void* ptr): base_t(cb, ptr) { }
132 | 		};
133 | 
134 | } // namespace coroutines
135 | 
136 | #endif /* YIELDER_H */
137 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_call.cpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #include <boost/test/unit_test.hpp>
 30 | #include <boost/ref.hpp>
 31 | #include <boost/tuple/tuple_comparison.hpp>
 32 | #include <boost/none.hpp>
 33 | #include <boost/function.hpp>
 34 | #include <boost/coroutine/coroutine.hpp>
 35 | #include <boost/coroutine/future.hpp>
 36 | 
 37 | 
 38 | namespace coroutines = boost::coroutines;
 39 | using coroutines::coroutine;
 40 | 
 41 | typedef coroutine<void()> coroutine_type;
 42 | 
 43 | class a_pipe {
 44 | public:
 45 |   
 46 |   void send(int x) {
 47 |     m_callback (x);
 48 |   }
 49 | 
 50 |   template<typename Callback>
 51 |   void listen(Callback c) {
 52 |     m_callback = c;
 53 |   }
 54 | private:
 55 |   boost::function<void(int)> m_callback;
 56 | };
 57 | 
 58 | struct coro_body {
 59 | 
 60 |   coro_body(bool& flag) :
 61 |     m_flag(flag) {
 62 |     m_flag = true;
 63 |   }
 64 | 
 65 |   ~coro_body() {
 66 |     m_flag = false;
 67 |   }
 68 |   bool &m_flag;
 69 | 
 70 |   typedef void result_type;
 71 | 
 72 |   void operator() (a_pipe& my_pipe, coroutine_type::self& self)  {
 73 |     typedef coroutines::future<int> future_type;
 74 |     future_type future(self);
 75 | 
 76 |     my_pipe.listen(coroutines::make_callback(future));
 77 |     coroutines::wait(future);
 78 |     BOOST_CHECK(future);
 79 | 
 80 |     BOOST_CHECK(*future == 1);
 81 |     future = boost::none;
 82 |     my_pipe.listen(coroutines::make_callback(future));
 83 |     coroutines::wait(future);
 84 |     BOOST_CHECK(*future == 2);
 85 |     future = boost::none;
 86 |     my_pipe.listen(coroutines::make_callback(future));
 87 |     coroutines::wait(future);
 88 |     BOOST_CHECK(*future == 3);
 89 |     future = boost::none;
 90 |     return;  
 91 |   }
 92 | };
 93 | 
 94 | void test_call() {
 95 |   bool run_flag = true;
 96 |   {
 97 |     a_pipe my_pipe;
 98 |     coroutine_type coro(boost::bind(coro_body(run_flag), boost::ref(my_pipe), _1));
 99 |     coro(std::nothrow);
100 |     my_pipe.send(1);
101 |     my_pipe.send(2);
102 |     my_pipe.send(3);
103 |   }
104 | 
105 |   //check for leaks
106 |   BOOST_CHECK(run_flag == false);
107 | }
108 | 
109 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
110 | {
111 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("call coroutine test");
112 | 
113 |     test->add(BOOST_TEST_CASE(&test_call));
114 | 
115 |     return test;
116 | }
117 | 


--------------------------------------------------------------------------------
/tests/stack/stack.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * stack.cpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #include <test.hpp>
  8 | #include <coroutine/stack.hpp>
  9 | #include <coroutine/impl/stack_static.hpp>
 10 | #include <coroutine/impl/stack_dynamic.hpp>
 11 | 
 12 | using namespace coroutine;
 13 | 
 14 | template <typename S>
 15 | void validateStack(S& s)
 16 | {
 17 | 	char* data = s.get_stack_ptr();
 18 | 	for (size_t i = 0; i < s.get_size(); ++i)
 19 | 		data[i] = (char)i;
 20 | 	for (size_t i = 0; i < s.get_size(); ++i)
 21 | 		BOOST_CHECK_EQUAL(data[i], (char)i);
 22 | }
 23 | 
 24 | BOOST_AUTO_TEST_CASE(test_dynamic_create)
 25 | {
 26 | 	{
 27 | 		stack::stack<stack::dynamic, 2048> a;
 28 | 		BOOST_CHECK_EQUAL(a.get_size(), 2048);
 29 | 		validateStack(a);
 30 | 	}
 31 | 
 32 | 	{
 33 | 		stack::stack<stack::dynamic, stack::size_in_b<1024>::value > a;
 34 | 		BOOST_CHECK_EQUAL(a.get_size(), 1024);
 35 | 	}
 36 | 
 37 | 	{
 38 | 		stack::stack<stack::dynamic, stack::size_in_kb<5>::value > a;
 39 | 		BOOST_CHECK_EQUAL(a.get_size(), 1024 * 5);
 40 | 		validateStack(a);
 41 | 	}
 42 | 
 43 | 	{
 44 | 		stack::stack<stack::dynamic, stack::size_in_mb<1>::value > a;
 45 | 		BOOST_CHECK_EQUAL(a.get_size(), 1024 * 1024);
 46 | 	}
 47 | }
 48 | 
 49 | BOOST_AUTO_TEST_CASE(test_dynamic_move)
 50 | {
 51 | 	{
 52 | 		typedef stack::stack<stack::dynamic, 2048> stack_t;
 53 | 		stack_t a;
 54 | 
 55 | 		char* data = a.get_stack_ptr();
 56 | 		for (size_t i = 0; i < a.get_size(); ++i)
 57 | 			data[i] = (char)i;
 58 | 
 59 | 		char* old_addr = a.get_stack_ptr();
 60 | 
 61 | 		stack_t b = std::move(a);
 62 | 
 63 | 		BOOST_CHECK_EQUAL(a.get_size(), 2048);
 64 | 		BOOST_CHECK_EQUAL((void*)a.get_stack_ptr(), (void*)0);
 65 | 
 66 | 		BOOST_CHECK_EQUAL(b.get_size(), 2048);
 67 | 		BOOST_CHECK_EQUAL((void*)b.get_stack_ptr(), (void*)old_addr);
 68 | 
 69 | 		data = b.get_stack_ptr();
 70 | 		for (size_t i = 0; i < b.get_size(); ++i)
 71 | 			BOOST_CHECK_EQUAL(data[i], (char)i);
 72 | 	}
 73 | }
 74 | 
 75 | BOOST_AUTO_TEST_CASE(test_static_)
 76 | {
 77 | 	{
 78 | 		stack::stack<stack::static_, 2048> a;
 79 | 		BOOST_CHECK_EQUAL(a.get_size(), 2048);
 80 | 		validateStack(a);
 81 | 	}
 82 | 
 83 | 	{
 84 | 		stack::stack<stack::static_, stack::size_in_b<1024>::value > a;
 85 | 		BOOST_CHECK_EQUAL(a.get_size(), 1024);
 86 | 	}
 87 | 
 88 | 	{
 89 | 		stack::stack<stack::static_, stack::size_in_kb<5>::value > a;
 90 | 		BOOST_CHECK_EQUAL(a.get_size(), 1024 * 5);
 91 | 		validateStack(a);
 92 | 	}
 93 | 
 94 | 	{
 95 | 		stack::stack<stack::static_, stack::size_in_mb<1>::value > a;
 96 | 		BOOST_CHECK_EQUAL(a.get_size(), 1024 * 1024);
 97 | 	}
 98 | }
 99 | 
100 | BOOST_AUTO_TEST_CASE(test_static__move)
101 | {
102 | 	{
103 | 		typedef stack::stack<stack::static_, 2048> stack_t;
104 | 		stack_t a;
105 | 
106 | 		char* data = a.get_stack_ptr();
107 | 		for (size_t i = 0; i < a.get_size(); ++i)
108 | 			data[i] = (char)i;
109 | 
110 | 		char* old_addr = a.get_stack_ptr();
111 | 
112 | 		stack_t b = std::move(a);
113 | 
114 | 		BOOST_CHECK_EQUAL(a.get_size(), 2048);
115 | 		BOOST_CHECK_EQUAL((void*)a.get_stack_ptr(), (void*)old_addr);
116 | 
117 | 		BOOST_CHECK_EQUAL(b.get_size(), 2048);
118 | 		BOOST_CHECK_NE((void*)b.get_stack_ptr(), (void*)old_addr);
119 | 
120 | 		data = b.get_stack_ptr();
121 | 		int same = 0;
122 | 		for (size_t i = 0; i < b.get_size(); ++i)
123 | 			data[i] == (char)i && ++same;
124 | 
125 | 		BOOST_CHECK_NE(same, b.get_size());
126 | 	}
127 | }
128 | 
129 | BOOST_AUTO_TEST_CASE(test_dynamic_really_moveable)
130 | {
131 | 	typedef stack::stack<stack::dynamic, 2048> stack_t;
132 | 	size_t v = stack::is_really_moveable<stack_t>::value;
133 | 	BOOST_CHECK_EQUAL(v, true);
134 | }
135 | 
136 | BOOST_AUTO_TEST_CASE(test_static__not_really_moveable)
137 | {
138 | 	typedef stack::stack<stack::static_, 2048> stack_t;
139 | 	size_t v = stack::is_really_moveable<stack_t>::value;
140 | 	BOOST_CHECK_EQUAL(v, false);
141 | }
142 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/src/swapcontext.cpp:
--------------------------------------------------------------------------------
 1 | //  Copyright (c) 2006, Giovanni P. Deretta
 2 | //
 3 | //  This code may be used under either of the following two licences:
 4 | //
 5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
 6 | //  of this software and associated documentation files (the "Software"), to deal 
 7 | //  in the Software without restriction, including without limitation the rights 
 8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
 9 | //  copies of the Software, and to permit persons to whom the Software is 
10 | //  furnished to do so, subject to the following conditions:
11 | //
12 | //  The above copyright notice and this permission notice shall be included in 
13 | //  all copies or substantial portions of the Software.
14 | //
15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
21 | //  THE SOFTWARE. OF SUCH DAMAGE.
22 | //
23 | //  Or:
24 | //
25 | //  Distributed under the Boost Software License, Version 1.0.
26 | //  (See accompanying file LICENSE_1_0.txt or copy at
27 | //  http://www.boost.org/LICENSE_1_0.txt)
28 | 
29 | 
30 | #if !defined(i386)
31 | #error This file is for x86 CPUs only.
32 | #endif
33 | 
34 | #if !defined(__GNUC__)
35 | #error This file requires gcc.
36 | #endif
37 | 
38 | /*
39 |  * This file should really be a plain assembler file.
40 |  * Unfortunately Boost.Build v2 doesn't handle asm files (yet).
41 |  * For now resort to inline asm.
42 |  */
43 | 
44 | 
45 | /* 
46 |    EAX is &from.sp	
47 |    EDX is to.sp
48 |    This is the simplest version of swapcontext
49 |    It saves registers on the old stack,
50 |    saves the old stack pointer, 
51 |    load the new stack pointer,
52 |    pop registers from the new stack
53 |    and returns to new caller.
54 |    EAX is simpy passed to the function it returns to.
55 |    The first time EAX is the first parameter of the trampoline.
56 |    Otherwise it is simply discarded.
57 |    NOTE: This function should work on any IA32 CPU.
58 |    NOTE: The biggest penality is the last jump that
59 |    will be always mispredicted (~50 cycles on P4).
60 |    We try to make its address available as soon as possible
61 |    to try to reduce the penality. Doing a ret instead of a 
62 |    'add $4, %esp'
63 |    'jmp *%ecx'
64 |    really kills performance.
65 |    NOTE: popl is slightly better than mov+add to pop registers
66 |    so is pushl rather than mov+sub.
67 |    */
68 | #define BOOST_COROUTINE_swapcontext(name) \
69 | asm volatile (                            \
70 | ".text \n\t"                              \
71 | ".global " #name "\n\t"                   \
72 | ".type " #name "@function\n\t"            \
73 | ".align 16\n\t"                           \
74 | #name":\n\t"                              \
75 | "movl  16(%edx), %ecx\n\t"                \
76 | "pushl %ebp\n\t"                          \
77 | "pushl %ebx\n\t"                          \
78 | "pushl %esi\n\t"                          \
79 | "pushl %edi\n\t"                          \
80 | "movl  %esp, (%eax)\n\t"                  \
81 | "movl  %edx, %esp\n\r"                    \
82 | "popl  %edi\n\t"                          \
83 | "popl  %esi\n\t"                          \
84 | "popl  %ebx\n\t"                          \
85 | "popl  %ebp\n\t"                          \
86 | "add   $4, %esp\n\t"                      \
87 | "jmp   *%ecx\n\t"                         \
88 | "ud2\n\t")                                \
89 | /**/
90 | 
91 | BOOST_COROUTINE_swapcontext(swapcontext_stack);
92 | BOOST_COROUTINE_swapcontext(swapcontext_stack2);
93 | BOOST_COROUTINE_swapcontext(swapcontext_stack3);
94 | 
95 | #undef BOOST_COROUTINE_swapcontext
96 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/wait_impl.hpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | 
 30 | #ifndef BOOST_COROUTINE_DETAIL_WAIT_IMPL_HPP_20060728
 31 | #define BOOST_COROUTINE_DETAIL_WAIT_IMPL_HPP_20060728
 32 | #include <boost/tuple/tuple.hpp>
 33 | #include <boost/coroutine/detail/signal.hpp>
 34 | namespace boost { namespace coroutines { namespace detail {
 35 | 
 36 |   /*
 37 |    * Inokes mark_wait('how') on the 'Idx'th element of 't'
 38 |    * then calls marker::wait<Idx-1> with the same arguments.
 39 |    * returns the result of marker::wait<Idx-1>(...) plus 1 if
 40 |    * the 'Idx'th.pending() is true or plus 0 otherwise.
 41 |    * 
 42 |    */
 43 |   template<int Idx>
 44 |   struct marker {
 45 |     template<typename Tuple>
 46 |     static int mark(Tuple& t, bool how) {
 47 |       wait_gateway::mark_wait(t.template get<Idx-1>(), how);
 48 |       return marker<Idx -1>::mark(t, how) + (t.template get<Idx-1>().pending()? 1:0);
 49 | 
 50 |     }
 51 |   };
 52 | 
 53 |   /* Recursion terminator */
 54 |   template<>
 55 |   struct marker<0> {
 56 |     template<typename Tuple>
 57 |     static int mark(Tuple&, bool) { return 0;}
 58 |   };
 59 | 
 60 |   template<typename Tuple>
 61 |   void wait_n(const Tuple& t, int n) {
 62 |     BOOST_STATIC_ASSERT(boost::tuples::length<Tuple>::value);
 63 |     wait_gateway::wait(t.get<0>(), n);
 64 |   }
 65 | 
 66 |   /*
 67 |    * Wait for at least one future in 'wt' tuple to be signaled.
 68 |    * If at least one future has been already signaled do not
 69 |    * block but returns immediatley (prevents deadlocks).
 70 |    */
 71 |   template<typename Tuple>
 72 |   void wait_impl(Tuple wt) {
 73 |     try {
 74 |       if(marker<boost::tuples::length<Tuple>::value>::mark(wt, true) > 0) 
 75 | 	wait_n(wt, 1);
 76 |     } catch (...) {
 77 |       marker<boost::tuples::length<Tuple>::value>::mark(wt, false);
 78 |       throw;
 79 |     }
 80 |     int res = marker<boost::tuples::length<Tuple>::value>::mark(wt, false);
 81 |     BOOST_ASSERT(res < boost::tuples::length<Tuple>::value);
 82 |     (void)res;
 83 |   }
 84 | 
 85 |   /*
 86 |    * Wait for all futures in 'wt' tuple to be signaled.
 87 |    */
 88 |   template<typename Tuple>
 89 |   void wait_all_impl(Tuple wt) {
 90 |     int res = marker<boost::tuples::length<Tuple>::value>::mark(wt, true);
 91 |     try {
 92 |       wait_n(wt, res);
 93 |     } catch (...) {
 94 |       marker<boost::tuples::length<Tuple>::value>::mark(wt, false);
 95 |       throw;
 96 |     }
 97 |     res = marker<boost::tuples::length<Tuple>::value>::mark(wt, false);
 98 |     BOOST_ASSERT(res == 0);
 99 |   }
100 | 
101 | } } }
102 | #endif
103 | 


--------------------------------------------------------------------------------
/include/coroutine/impl/context_linux_x86_32.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * context_linux_x86_32.hpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #pragma once
  8 | #ifndef CONTEXT_LINUX_X86_32_H
  9 | #define CONTEXT_LINUX_X86_32_H
 10 | 
 11 | #include <coroutine/stack.hpp>
 12 | 
 13 | /*
 14 |  * Enabled, will use a copy paste of the code
 15 |  * (implemented trough template).
 16 |  */
 17 | #ifndef NO_CORO_LINUX_8632_2SWAPSITE
 18 | #	define CORO_LINUX_8632_2SWAPSITE
 19 | #endif
 20 | 
 21 | namespace coroutine {
 22 | 	namespace context {
 23 | 
 24 | 		struct linux_x86_32: context_tag {
 25 | 			template <typename STACK>
 26 | 				struct default_stack_size: stack::size_in_mb<32> {};
 27 | 		};
 28 | 
 29 | 		template <>
 30 | 			struct linux_x86_32::default_stack_size<stack::static_>
 31 | 			: stack::size_in_mb<4> {};
 32 | 
 33 | 		template <class STACK>
 34 | 			struct context<linux_x86_32, STACK> {
 35 | 				typedef void (function_t)(void*);
 36 | 
 37 | 			public:
 38 | 				typedef STACK stack_t;
 39 | 
 40 | 				context(function_t* f, void* arg):
 41 | 					_f(f), _arg(arg) { reset(); }
 42 | 
 43 | 				context(const Context& from) = delete;
 44 | 				context& operator=(const Context& from) = delete;
 45 | 
 46 | 				void reset()
 47 | 				{
 48 | 					_sp = reinterpret_cast<void**>(_stack.get_stack_ptr())
 49 | 						+ _stack.get_size() / sizeof(void*);
 50 | 
 51 | 					*--_sp = _funcptr;      // (trampoline arg2)
 52 | 					*--_sp = (void*)this;   // (trampoline arg1)
 53 | 					*--_sp = 0;             // trampoline return
 54 | 					*--_sp = (void*)_cbptr; // next instruction addr
 55 | 					--_sp;                  // rbp
 56 | 				}
 57 | 
 58 | 				void run()
 59 | 				{
 60 | #ifdef    CORO_LINUX_8632_2SWAPSITE
 61 | 					swapContext<1>();
 62 | #else  // !CORO_LINUX_8632_2SWAPSITE
 63 | 					swapContext();
 64 | #endif // CORO_LINUX_8632_2SWAPSITE
 65 | 				}
 66 | 				void yield()
 67 | 				{
 68 | #ifdef    CORO_LINUX_8632_2SWAPSITE
 69 | 					swapContext<1>();
 70 | #else  // !CORO_LINUX_8632_2SWAPSITE
 71 | 					swapContext();
 72 | #endif // CORO_LINUX_8632_2SWAPSITE
 73 | 				}
 74 | 
 75 | 				static const char* getImplName() { return "linux x86_32"; }
 76 | 
 77 | 			private:
 78 | 				function_t* _cbptr;
 79 | 				void*       _funcptr;
 80 | 				void**      _sp;
 81 | 				Stack       _stack;
 82 | 
 83 | 				template <typename C, typename F>
 84 | 					static void trampoline(C* context, F f)
 85 | 					{
 86 | 						(*f)();
 87 | 						context->yield();
 88 | 						abort();
 89 | 					}
 90 | 
 91 | #ifdef    CORO_LINUX_8632_2SWAPSITE
 92 | 				template <int>
 93 | #endif // CORO_LINUX_8632_2SWAPSITE
 94 | 					void swapContext()
 95 | 					{
 96 | 						asm volatile (
 97 | 								// store next instruction
 98 | 								"push $1f\n\t"
 99 | 
100 | 								// store registers
101 | 								"push %%ebp\n\t"
102 | 
103 | 								// switch stack
104 | 								"xchg (%[_sp]), %%esp\n\t"
105 | 
106 | 								// restore registers
107 | 								"pop %%ebp\n\t"
108 | 
109 | 								// jump to next instruction
110 | 								"pop %%eax\n\t"
111 | 								"jmp *%%eax\n\t"
112 | 
113 | 								"1:\n\t"
114 | 
115 | 								: // output
116 | 								// not used
117 | 								: // input
118 | 								[_sp]   "d" (&_sp)
119 | 								: // modified
120 | 									"eax", "ebx", "ecx",
121 | 									// edx -> used as input
122 | 									// esp -> manipulated behind the
123 | 									// compiler.
124 | 									// ebp -> can be used by compiler in
125 | 									// debug mode, so we saving it manually.
126 | 									//  - GCC in -O0 mode reserve *bp.
127 | 									//  - LLVM doesn't seem to have this
128 | 									//  caveat.
129 | 									"esi", "edi",
130 | 									"%st(1)", "%st(2)", "%st(3)", "%st(4)",
131 | 									"%st(5)", "%st(6)", "%st(7)",
132 | 									"mm0", "mm1", "mm2", "mm3", "mm4",
133 | 									"mm5", "mm6", "mm7",
134 | 									"xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
135 | 									"xmm5", "xmm6",	"xmm7",
136 | 									"memory"
137 | 									 );
138 | 					}
139 | 			};
140 | 
141 | 	} // namespace context
142 | } // namespace coroutine
143 | 
144 | #endif /* CONTEXT_LINUX_X86_32_H */
145 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/example/scheduler_wait.cpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #include <iostream>
 30 | #include <string>
 31 | #include <boost/coroutine/shared_coroutine.hpp>
 32 | #include <boost/bind.hpp>
 33 | #include <boost/lexical_cast.hpp>
 34 | #include <queue>
 35 | #include <list>
 36 | 
 37 | namespace coro = boost::coroutines;
 38 | using coro::shared_coroutine;
 39 | 
 40 | typedef shared_coroutine<void()> job_type;
 41 | 
 42 | class scheduler {
 43 | public:
 44 |   void add(job_type job) {
 45 |     BOOST_ASSERT(job);
 46 |     m_queue.push(job);
 47 |   }
 48 |   
 49 |   void reschedule(job_type::self& self) {
 50 |     BOOST_ASSERT(current());
 51 |     add(current());
 52 |     self.yield();
 53 |   }
 54 | 
 55 |   job_type& current() {
 56 |     BOOST_ASSERT(m_current);
 57 |     return m_current;
 58 |   }
 59 | 
 60 |   void run () {
 61 |     while(!m_queue.empty()) {
 62 |       pop();    
 63 |       current()(std::nothrow);	
 64 |     }
 65 | 
 66 |   }
 67 | private:
 68 |   void pop() {
 69 |     m_current = m_queue.front();
 70 |     m_queue.pop();
 71 |   }
 72 | 
 73 |   std::queue<job_type> m_queue;
 74 |   job_type m_current;
 75 | };
 76 | 
 77 | class message_queue {
 78 | public:
 79 |   std::string pop(job_type::self& self) {
 80 |     while(m_queue.empty()) {
 81 |       m_waiters.push(m_scheduler.current());
 82 |       self.yield();      
 83 |     }
 84 |     BOOST_ASSERT(!m_queue.empty());
 85 |     std::string res = m_queue.front();
 86 |     m_queue.pop();
 87 |     return res;
 88 |   }
 89 | 
 90 |   void push(const std::string& val) {
 91 |     m_queue.push(val);
 92 |     while(!m_waiters.empty()) {
 93 |       m_scheduler.add(m_waiters.front());
 94 |       m_waiters.pop();
 95 |     }
 96 |   }
 97 | 
 98 |   message_queue(scheduler& s) :
 99 |     m_scheduler(s) {}
100 | 
101 | private:
102 |   std::queue<std::string> m_queue;
103 |   std::queue<job_type> m_waiters;
104 |   scheduler & m_scheduler;
105 | };
106 | 
107 | scheduler global_scheduler;
108 | message_queue mqueue(global_scheduler);
109 | 
110 | void producer(job_type::self& self, int id, int count) {
111 |   while(--count) {
112 |     std::cout << "In producer: "<<id<<", left: "<<count <<"\n";
113 |     mqueue.push("message from " + boost::lexical_cast<std::string>(id));
114 |     std::cout << "\tmessage sent\n";
115 |     global_scheduler.reschedule(self);
116 |   } 
117 | }
118 | 
119 | void consumer(job_type::self& self, int id) {
120 |   while(true) {
121 |     std::string result = mqueue.pop(self);
122 |     std::cout <<"In consumer: "<<id<<"\n";
123 |     std::cout <<"\tReceived: "<<result<<"\n";
124 |   }
125 | }
126 | 
127 | int main() {
128 |   global_scheduler.add(boost::bind(producer, _1, 0, 4));
129 |   global_scheduler.add(boost::bind(producer, _1, 1, 3));
130 |   global_scheduler.add(boost::bind(producer, _1, 2, 2));
131 |   global_scheduler.add(boost::bind(consumer, _1, 3));
132 |   global_scheduler.add(boost::bind(consumer, _1, 4));
133 |   global_scheduler.run();
134 | }
135 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/future_impl.hpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #ifndef BOOST_COROUTINE_DETAIL_FUTURE_IMPL_HPP_20060809
 30 | #define BOOST_COROUTINE_DETAIL_FUTURE_IMPL_HPP_20060809
 31 | #include <boost/optional.hpp>
 32 | #include <boost/assert.hpp>
 33 | #include <boost/optional.hpp>
 34 | #include <boost/noncopyable.hpp>
 35 | #include <boost/coroutine/detail/coroutine_accessor.hpp>
 36 | #include <boost/coroutine/detail/context_base.hpp>
 37 | 
 38 | namespace boost { namespace coroutines { namespace detail {
 39 | 
 40 | 
 41 |   template<typename ValueType, typename ContextImpl>
 42 |   class future_impl : boost::noncopyable  {
 43 |   public:
 44 |     typedef ValueType value_type;
 45 |     typedef 
 46 |     context_base<ContextImpl> *      
 47 |     context_weak_pointer;
 48 |     
 49 |     typedef 
 50 |     BOOST_DEDUCED_TYPENAME
 51 |     context_base<ContextImpl>::pointer
 52 |     context_pointer;
 53 | 
 54 |     typedef boost::optional<value_type> pointer;
 55 | 
 56 |     template<typename CoroutineSelf>
 57 |     future_impl(CoroutineSelf& self) :
 58 |       m_coro_impl_weak(coroutine_accessor::get_impl(self)),
 59 |       m_coro_impl(0),
 60 |       m_waited(false)
 61 |     {}
 62 | 
 63 |     value_type& 
 64 |     value() {
 65 |       return *m_optional;
 66 |     }
 67 | 
 68 |     value_type const& 
 69 |     value() const{
 70 |       return *m_optional;
 71 |     }
 72 | 
 73 |     pointer& 
 74 |     get() {
 75 |       return m_optional;
 76 |     }
 77 | 
 78 |     pointer const& 
 79 |     get() const{
 80 |       return m_optional;
 81 |     }
 82 | 
 83 |     bool pending() {
 84 |       return 0 != m_coro_impl.get();
 85 |     }
 86 |     
 87 |     template<typename T>
 88 |     void assign(const T& val) {
 89 |       BOOST_ASSERT(pending());
 90 |       context_pointer p = m_coro_impl;
 91 |       m_coro_impl = 0;
 92 |       m_optional = val;
 93 |       p->count_down();
 94 |       if(waited() && p->signal())
 95 | 	p->wake_up();
 96 |     }
 97 | 
 98 |     void mark_pending() {
 99 |       m_coro_impl = m_coro_impl_weak;
100 |       m_coro_impl ->count_up();
101 |     }
102 | 
103 |     void mark_wait(bool how) {
104 |       m_waited = how;
105 |     }
106 | 
107 |     bool waited() const {
108 |       return m_waited;
109 |     }
110 | 
111 |     context_pointer context() {
112 |       BOOST_ASSERT(pending());
113 |       return m_coro_impl;
114 |     }
115 |         
116 |     void wait(int n) {
117 |       m_coro_impl_weak->wait(n);
118 |     }
119 | 
120 |     void wait() {
121 |       if(!pending()) return;
122 |       mark_wait(true);
123 |       try {
124 | 	m_coro_impl->wait(1);
125 | 	BOOST_ASSERT(!pending());
126 |       } catch (...) {
127 | 	mark_wait(false);
128 | 	throw;
129 |       }
130 |       mark_wait(false);
131 |     }
132 | 
133 |   private:
134 |     context_weak_pointer m_coro_impl_weak;
135 |     context_pointer m_coro_impl;
136 |     bool m_waited;
137 |     boost::optional<value_type> m_optional;
138 |   };
139 | } } }
140 | #endif
141 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | #
  2 | # CMakeLists.txt
  3 | # Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 | #
  5 | #
  6 | 
  7 | cmake_minimum_required(VERSION 2.6)
  8 | 
  9 | project(zia CXX)
 10 | 
 11 | ###############################################################################
 12 | # BOOST CONFIGURATION
 13 | ###############################################################################
 14 | 
 15 | set(Boost_USE_STATIC_LIBS   OFF)
 16 | set(Boost_USE_MULTITHREADED ON)
 17 | set(BOOST_INCLUDEDIR "/usr/local/include")
 18 | set(Boost_ADDITIONAL_VERSIONS 1.47 1.46 1.44 1.43 1.42 1.41 1.40 1.39)
 19 | add_definitions(-DBOOST_ALL_NO_LIB)
 20 | 
 21 | ###############################################################################
 22 | # COMPILER FLAGS
 23 | ###############################################################################
 24 | 
 25 | if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_COMPILER_IS_GNUCXX)
 26 | 	set(PROFILING false CACHE BOOL "Use profilling")
 27 | 	if (PROFILING)
 28 | 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg")
 29 | 		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg")
 30 | 	endif()
 31 | 
 32 | 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-stack-protector")
 33 | 
 34 | 	set(EXTRADEBUG false CACHE BOOL "Force extra debug info")
 35 | 	
 36 | 	set(NATIVECODE false CACHE BOOL "Generate native code")
 37 | 	if (NATIVECODE)
 38 | 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
 39 | 	endif()
 40 | 
 41 | 	set(NOELIDECTOR false CACHE BOOL "Disable elide contructors optimization")
 42 | 	if (NOELIDECTOR)
 43 | 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-elide-constructors")
 44 | 	endif()
 45 | endif()
 46 | 
 47 | if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 48 | 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
 49 | 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
 50 | 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
 51 | 	
 52 | 	if (EXTRADEBUG)
 53 | 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3")
 54 | 	endif()
 55 | 	
 56 | 	set(OMIT_FRAME_POINTER true CACHE BOOL "Omit frame pointer")
 57 | 	if (OMIT_FRAME_POINTER)
 58 | 		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
 59 | 	endif()
 60 | 
 61 | 	# ugly temparary hack
 62 | 	include_directories(
 63 | 		"/usr/include/x86_64-linux-gnu/"
 64 | 		"/usr/include/i386-linux-gnu/"
 65 | 		)
 66 | endif()
 67 | 
 68 | if (CMAKE_COMPILER_IS_GNUCXX)
 69 | 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
 70 | 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra")
 71 | 	
 72 | 	if (EXTRADEBUG)
 73 | 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3 -D_GLIBCXX_DEBUG")
 74 | 	endif()
 75 | 	
 76 | 	include(CheckCXXCompilerFlag OPTIONAL RESULT_VARIABLE CMAKE_CHECK_CXX_FLAGS)
 77 | 	if (CMAKE_CHECK_CXX_FLAGS)
 78 | 		CHECK_CXX_COMPILER_FLAG(-flto GCC_WITH_LTO)
 79 | 		if (GCC_WITH_LTO)
 80 | 			set(LTO true CACHE BOOL "Use GCC Link Time Optimisation.")
 81 | 		endif(GCC_WITH_LTO)
 82 | 		CHECK_CXX_COMPILER_FLAG(-fwhole-program GCC_WITH_WP)
 83 | 		if (GCC_WITH_WP)
 84 | 			set(LTO_WP false CACHE BOOL
 85 | 				"Use GCC Whole Program Link Time Optimisation.")
 86 | 		endif(GCC_WITH_WP)
 87 | 	endif(CMAKE_CHECK_CXX_FLAGS)
 88 | 	
 89 | 	if (LTO)
 90 | 		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto")
 91 | 		set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -flto")
 92 | 	endif()
 93 | 	
 94 | 	if (LTO_WP)
 95 | 		set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -fwhole-program")
 96 | 		set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE}
 97 | 			-fwhole-program")
 98 | 	endif()
 99 | endif(CMAKE_COMPILER_IS_GNUCXX)
100 | 
101 | ###############################################################################
102 | # COROUTINE CONFIGURATION
103 | ###############################################################################
104 | include_directories(${CMAKE_SOURCE_DIR}/include)
105 | 
106 | set(LINUX_8664_2SWAPSITE true CACHE BOOL
107 | 	"Linux x86_64: swapContext copy pasted for help CPU prediction")
108 | if (NOT LINUX_8664_2SWAPSITE)
109 | 	add_definitions(-DNO_CORO_LINUX_8664_2SWAPSITE)
110 | endif()
111 | 
112 | set(LINUX_8632_2SWAPSITE true CACHE BOOL
113 | 	"Linux x86_32: swapContext copy pasted for help CPU prediction")
114 | if (NOT LINUX_8632_2SWAPSITE)
115 | 	add_definitions(-DNO_CORO_LINUX_8632_2SWAPSITE)
116 | endif()
117 | 
118 | ###############################################################################
119 | # SUBDIRS
120 | ###############################################################################
121 | 
122 | enable_testing()
123 | add_subdirectory(tests)
124 | add_subdirectory(benchmarks)
125 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/call_impl.hpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #ifndef BOOST_COROUTINE_DETAIL_CALL_IMPL_HPP_20060728
 30 | #define BOOST_COROUTINE_DETAIL_CALL_IMPL_HPP_20060728
 31 | 
 32 | #include <boost/preprocessor/repetition.hpp>
 33 | #include <boost/call_traits.hpp>
 34 | #include <boost/tuple/tuple.hpp>
 35 | #include <boost/bind.hpp>
 36 | #include <boost/coroutine/coroutine.hpp>
 37 | #include <boost/coroutine/detail/arg_max.hpp>
 38 | #include <boost/coroutine/detail/signal.hpp>
 39 | #include <boost/coroutine/detail/coroutine_accessor.hpp>
 40 | namespace boost { namespace coroutines { namespace detail {
 41 | 
 42 | #define BOOST_COROUTINE_tuple_param_n(z, n, tuple)\
 43 |   BOOST_DEDUCED_TYPENAME                          \
 44 |   boost::tuples::element<n, tuple>::type          \
 45 |   BOOST_PP_CAT(arg, n)                            \
 46 |  /**/
 47 | 
 48 |   template<typename Future>                       
 49 |   class callback {
 50 |   public:
 51 | 
 52 |     typedef void result_type;
 53 |     
 54 |     callback(Future& future) :
 55 |       m_future_pimpl(wait_gateway::get_impl(future)) {
 56 |       m_future_pimpl->mark_pending();
 57 |     }
 58 |     
 59 |     typedef BOOST_DEDUCED_TYPENAME                
 60 |     Future::tuple_type tuple_type;              
 61 | 
 62 |     typedef BOOST_DEDUCED_TYPENAME                
 63 |     Future::tuple_traits_type tuple_traits_type;              
 64 | 
 65 |     /*
 66 |      * By default a callback is one shot only.
 67 |      * By calling this method you can revive a 
 68 |      * callback for another shot.
 69 |      * You must guaranee that the future
 70 |      * is still alive.
 71 |      */
 72 |     void revive() {
 73 |       m_future_pimpl->mark_pending();
 74 |     }
 75 | 
 76 | #define BOOST_COROUTINE_gen_argn_type(z, n, unused) \
 77 |     typedef BOOST_DEDUCED_TYPENAME                  \
 78 |     tuple_traits_type::                             \
 79 |     template at<n>::type                            \
 80 |     BOOST_PP_CAT(BOOST_PP_CAT(arg, n), _type);      \
 81 | /**/
 82 | 
 83 |     BOOST_PP_REPEAT(BOOST_COROUTINE_ARG_MAX,
 84 | 		    BOOST_COROUTINE_gen_argn_type,
 85 | 		    ~);
 86 |       
 87 | #define BOOST_COROUTINE_param_with_default(z, n, type_prefix) \
 88 |     BOOST_DEDUCED_TYPENAME call_traits                   \
 89 |     <BOOST_PP_CAT(BOOST_PP_CAT(type_prefix, n), _type)>  \
 90 |     ::param_type                                         \
 91 |     BOOST_PP_CAT(arg, n) =                               \
 92 |     BOOST_PP_CAT(BOOST_PP_CAT(type_prefix, n), _type)()  \
 93 | /**/
 94 |     
 95 |     void operator() 
 96 |       (BOOST_PP_ENUM
 97 |        (BOOST_COROUTINE_ARG_MAX,
 98 | 	BOOST_COROUTINE_param_with_default,
 99 | 	arg)) {
100 |       m_future_pimpl->assign(tuple_type
101 | 	(BOOST_PP_ENUM_PARAMS
102 | 	 (BOOST_COROUTINE_ARG_MAX, arg)));
103 |     }
104 | 
105 |   private:
106 |     BOOST_DEDUCED_TYPENAME
107 |     Future::impl_pointer
108 |     m_future_pimpl;
109 |   };  
110 |   
111 | #undef BOOST_COROUTINE_gen_future_assigner
112 | #undef BOOST_COROUTINE_tuple_param_n
113 | 
114 |   template<typename Future, typename Functor, typename CoroutineSelf>
115 |   Future call_impl(Functor fun, const CoroutineSelf& coro_self) {
116 |     Future future(coro_self);
117 |     fun(callback<Future>(future));
118 |     return future;
119 |   }
120 | 
121 | } } }
122 | 
123 | #endif
124 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/boost/coroutine/detail/posix_utility.hpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #ifndef BOOST_COROUTINE_DETAIL_POSIX_UTILITY_HPP_02012006
 30 | #define BOOST_COROUTINE_DETAIL_POSIX_UTILITY_HPP_02012006
 31 | #include <boost/config.hpp>
 32 | 
 33 | #if defined(_POSIX_VERSION)
 34 | /**
 35 |  * Most of these utilities are really pure C++, but they are useful
 36 |  * only on posix systems.
 37 |  */
 38 | #include <cerrno>
 39 | #include <cstddef>
 40 | #include <cstdlib>
 41 | #include <iostream>
 42 | #include <boost/type_traits.hpp>
 43 | /**
 44 |  * Stack allocation routines and trampolines for setcontext
 45 |  */
 46 | namespace boost { namespace coroutines { namespace detail { namespace posix {
 47 | 
 48 |   
 49 |   //this should be a fine default.
 50 |   static const std::size_t stack_alignment = sizeof(void*) > 16? sizeof(void*): 16;
 51 | 
 52 |   struct stack_aligner {
 53 |     boost::type_with_alignment<stack_alignment>::type dummy;
 54 |   };
 55 | 
 56 |   /**
 57 |    * Stack allocator and deleter functions.
 58 |    * Better implementations are possible using
 59 |    * mmap (might be required on some systems) and/or
 60 |    * using a pooling allocator.
 61 |    * NOTE: the SuSv3 documentation explictly allows
 62 |    * the use of malloc to allocate stacks for makectx.
 63 |    * We use free for guaranteed alignment.
 64 |    */
 65 |   inline
 66 |   void* alloc_stack(std::size_t size) {
 67 |     return new stack_aligner[size/sizeof(stack_aligner)];
 68 |   }
 69 | 
 70 |   inline
 71 |   void free_stack(void* stack, std::size_t size) {
 72 |     delete [] static_cast<stack_aligner*>(stack);
 73 |   }
 74 | 
 75 |   /**
 76 |    * The splitter is needed for 64 bit systems. 
 77 |    * @note The current implementation does NOT use
 78 |    * (for debug reasons).
 79 |    * Thus it is not 64 bit clean.
 80 |    * Use it for 64 bits systems.
 81 |    */
 82 |   template<typename T>
 83 |   union splitter {
 84 |     int int_[2];
 85 |     T* ptr;
 86 |     splitter(int first, int second) {
 87 |       int_[0] = first;
 88 |       int_[1] = second;
 89 |     }
 90 | 
 91 |     int first() {
 92 |       return int_[0];
 93 |     }
 94 | 
 95 |     int second() {
 96 |       return int_[1];
 97 |     }
 98 | 
 99 |     splitter(T* ptr) :ptr(ptr) {}
100 | 
101 |     void operator()() {
102 |       (*ptr)();
103 |     }
104 |   };
105 | 
106 |   template<typename T>
107 |   inline
108 |   void
109 |   trampoline_split(int first, int second) {
110 |     splitter<T> split(first, second);
111 |     split();
112 |   }
113 | 
114 |   template<typename T>
115 |   inline
116 |   void
117 |   trampoline(T * fun) {
118 |     (*fun)();
119 |   }
120 | }
121 | } } }
122 | 
123 | #if defined(_POSIX_MAPPED_FILES) && _POSIX_MAPPED_FILES > 0
124 | #include <sys/mman.h>
125 | namespace boost { namespace coroutines { namespace detail { namespace posix {
126 |   inline 
127 |   void * 
128 |   alloc_stack_mmap(std::size_t size) {
129 |     void * stack = ::mmap(NULL,
130 | 			  size,
131 | 			  PROT_EXEC|PROT_READ|PROT_WRITE,
132 | 			  MAP_PRIVATE|MAP_ANONYMOUS,
133 | 			  -1,
134 | 			  0
135 | 			  );
136 |     if(stack == MAP_FAILED) {
137 |       std::cerr <<strerror(errno)<<"\n";
138 |       abort();
139 |     }
140 |     return stack;
141 |   }
142 | 
143 |   inline
144 |   void free_stack_mmap(void* stack, std::size_t size) {
145 |     ::munmap(stack, size);
146 |   }
147 | } } } }
148 | #endif
149 | #else
150 | #error This header can only be included when compiling for posix systems.
151 | #endif
152 | 
153 | #endif
154 | 


--------------------------------------------------------------------------------
/benchmarks/deretta-coroutine/libs/coroutine/test/test_create.cpp:
--------------------------------------------------------------------------------
  1 | //  Copyright (c) 2006, Giovanni P. Deretta
  2 | //
  3 | //  This code may be used under either of the following two licences:
  4 | //
  5 | //  Permission is hereby granted, free of charge, to any person obtaining a copy 
  6 | //  of this software and associated documentation files (the "Software"), to deal 
  7 | //  in the Software without restriction, including without limitation the rights 
  8 | //  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
  9 | //  copies of the Software, and to permit persons to whom the Software is 
 10 | //  furnished to do so, subject to the following conditions:
 11 | //
 12 | //  The above copyright notice and this permission notice shall be included in 
 13 | //  all copies or substantial portions of the Software.
 14 | //
 15 | //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 16 | //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 17 | //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 18 | //  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 19 | //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
 20 | //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
 21 | //  THE SOFTWARE. OF SUCH DAMAGE.
 22 | //
 23 | //  Or:
 24 | //
 25 | //  Distributed under the Boost Software License, Version 1.0.
 26 | //  (See accompanying file LICENSE_1_0.txt or copy at
 27 | //  http://www.boost.org/LICENSE_1_0.txt)
 28 | 
 29 | #include <iostream>
 30 | #include <boost/coroutine/coroutine.hpp>
 31 | #include <boost/test/unit_test.hpp>
 32 | 
 33 | namespace coroutines = boost::coroutines;
 34 | using coroutines::coroutine;
 35 | 
 36 |  
 37 | struct my_result {};
 38 | struct my_parm {};
 39 | 
 40 | typedef coroutine<my_result(my_parm)> coroutine_type;
 41 | typedef coroutine<void()> coroutine_vv_type;
 42 | typedef coroutine<int()> coroutine_iv_type;
 43 | typedef coroutine<void(int)> coroutine_vi_type;
 44 | 
 45 | typedef boost::tuple<my_result, my_result> result_tuple;
 46 | typedef boost::coroutines::tuple_traits<my_result, my_result> result_tuple_tag;
 47 | typedef coroutine<result_tuple_tag (my_parm)> coroutine_tuple_type;
 48 | 
 49 | typedef boost::tuple<my_parm, my_parm> parm_tuple;
 50 | typedef coroutine<my_result(my_parm, my_parm)> coroutine_tuple2_type;
 51 | 
 52 | my_result foo(coroutine_type::self& self, my_parm parm) {
 53 |   int i = 10;
 54 |   my_result t;
 55 |   while(--i) {
 56 |     std::cout<<i <<", in coroutine, yielding\n";
 57 |     parm = self.yield(t);
 58 |   }
 59 |   std::cout<<i <<", in coroutine, exiting\n";
 60 |   return t;
 61 | }
 62 | 
 63 | struct foo_functor {
 64 |   typedef my_result result_type;
 65 |   my_result operator()(coroutine_type::self& self, my_parm parm) {
 66 |     return foo(self, parm);
 67 |   }
 68 | };
 69 | 
 70 | foo_functor
 71 | make_foo_functor() {
 72 |   return foo_functor();
 73 | }
 74 | 
 75 | int bar(coroutine_iv_type::self& self) {
 76 |   self.yield(0);
 77 |   return 0;
 78 | }
 79 | 
 80 | result_tuple baz(coroutine_tuple_type::self& self, my_parm) {
 81 |   self.yield(my_result(), my_result()); 
 82 |   return boost::make_tuple(my_result(), my_result());
 83 | }
 84 | 
 85 | my_result barf(coroutine_tuple2_type::self& self, my_parm a, my_parm b) {
 86 |   boost::tie(a, b) = self.yield(my_result());
 87 |   return my_result();
 88 | }
 89 | 
 90 | void vi(coroutine_vi_type::self& self, int i) {
 91 |   i = self.yield();
 92 | }
 93 | 
 94 | void vv(coroutine_vv_type::self& self) {
 95 |   self.yield();
 96 | }
 97 | 
 98 | typedef coroutine<void(int&)> coroutine_ref_type;
 99 | void ref(coroutine_ref_type::self& self, int& x) {
100 |   x = 10;
101 |   self.yield();
102 | }
103 | 
104 | void test_create() {
105 |   coroutine <my_result(my_parm)> empty;
106 |   coroutine <my_result(my_parm)> coro(foo);
107 |   BOOST_CHECK(!empty);
108 |   swap(empty, coro);
109 |   BOOST_CHECK(empty);
110 |   swap(empty, coro);
111 | 
112 |   coroutine_type coro_functor(make_foo_functor());
113 |   my_parm t;
114 | 
115 |   /* Void parameters are supported */
116 |   coroutine_iv_type iv_coro(bar);
117 |   /* Void results are supported */
118 |  coroutine_vi_type vi_coro (vi);
119 |   /* Void values and parameters are supported*/  
120 |   coroutine_vv_type void_coro (vv); 
121 |   /* Tuple result types are supported */
122 |   coroutine_tuple_type tuple_coro(baz);
123 |   /* Variable arity coroutines are supported */
124 |   coroutine_tuple2_type tuple2_coro(barf);
125 |   tuple2_coro(my_parm(), my_parm());
126 |   /* references are supported */
127 |   coroutine_ref_type ref_coro(ref);
128 |   int x = 0;
129 |   ref_coro(x);
130 |   BOOST_CHECK(x == 10);
131 | 
132 |   while(coro && coro_functor) {
133 |     coro(t);
134 |     coro_functor(t);
135 |   }
136 |   BOOST_CHECK(!(coro && coro_functor));
137 | }
138 | 
139 | boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
140 | {
141 |     boost::unit_test::test_suite *test = BOOST_TEST_SUITE("create coroutine test");
142 | 
143 |     test->add(BOOST_TEST_CASE(&test_create));
144 | 
145 |     return test;
146 | }
147 | 


--------------------------------------------------------------------------------
/tests/coroutine/coroutine.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * createCoroutine.cpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #include <test.hpp>
  8 | #include <coroutine/builder.hpp>
  9 | #include <iostream>
 10 | #include <coroutine/impl/context_posix.hpp>
 11 | #include <coroutine/stack.hpp>
 12 | 
 13 | using namespace coroutine;
 14 | 
 15 | #if 0
 16 | int f_ret_feed(yielder<int (float)> yield, float v)
 17 | {
 18 | 	BOOST_CHECK(v == 2.2f);
 19 | 	std::cout << "v=" << v << std::endl;
 20 | 	float a = yield(42);
 21 | 	BOOST_CHECK(a == 99.f);
 22 | 	std::cout << "a=" << a << std::endl;
 23 | 	return 84;
 24 | }
 25 | 
 26 | BOOST_AUTO_TEST_CASE(ret_feed)
 27 | {
 28 | 	auto c = corof<stack::dynamic, context::posix>(&f_ret_feed);
 29 | 
 30 | 	int r1 = c(2.2f);
 31 | 	BOOST_CHECK_EQUAL(r1, 42);
 32 | 	std::cout << "r1=" << r1 << std::endl;
 33 | 	int r2 = c(99.f);
 34 | 	BOOST_CHECK(r2 == 84);
 35 | 	std::cout << "r2=" << r2 << std::endl;
 36 | }
 37 | #endif
 38 | 
 39 | struct Speaker {
 40 | 	const char* _msg;
 41 | 	Speaker(const char* msg): _msg(msg) {}
 42 | 	Speaker(const Speaker& from): _msg(from._msg) {
 43 | 		std::cout << "copy: " << msg() << std::endl;
 44 | 	}
 45 | 	Speaker(Speaker&& from): _msg(from._msg) {
 46 | 		from._msg = "wiped";
 47 | 		std::cout << "move: " << msg() << std::endl;
 48 | 	}
 49 | 	const char* msg() const { return _msg; }
 50 | };
 51 | 
 52 | int f_elide_cpy(yielder<int (int)> yield, int v)
 53 | {
 54 | 	std::cout << "f_elide_cpy " << v << std::endl;
 55 | 	return 10;
 56 | }
 57 | 
 58 | Speaker f_elide_cpyu(yielder<Speaker (int)> yield, int)
 59 | {
 60 | //    yield(Speaker("yielded 1"));
 61 | //    yield(Speaker("yielded 2"));
 62 | 	return Speaker("returned");
 63 | }
 64 | 
 65 | BOOST_AUTO_TEST_CASE(elide_cpy)
 66 | {
 67 | 	auto c = corof<stack::dynamic, context::posix, stack::size_in_mb<64> >(&f_elide_cpy);
 68 | 
 69 | //    yielder<int (float)> a(( float (*)(void*, int) )reinterpret_cast<void*>(42), reinterpret_cast<void*>(21));
 70 | //    auto b = a;
 71 | 
 72 | 	auto a = c(42);
 73 | //    std::cout << a.msg() << std::endl;
 74 | //    auto b = c(42);
 75 | //    std::cout << b.msg() << std::endl;
 76 | //    auto d = c(42);
 77 | //    std::cout << d.msg() << std::endl;
 78 | }
 79 | 
 80 | 
 81 | #if 0
 82 | int f_ret(yielder<int> yield)
 83 | {
 84 | 	yield(43);
 85 | 	return 85;
 86 | }
 87 | 
 88 | BOOST_AUTO_TEST_CASE(ret)
 89 | {
 90 | 	typedef Coroutine<int, void, int (*)(yielder<int>),
 91 | 		1024*8, stack::Default, context> coro_t;
 92 | 
 93 | 	coro_t c(&f_ret);
 94 | 
 95 | 	int r1 = c();
 96 | 	BOOST_CHECK(r1 == 43);
 97 | 	std::cout << "r1=" << r1 << std::endl;
 98 | 	int r2 = c();
 99 | 	BOOST_CHECK(r2 == 85);
100 | 	std::cout << "r2=" << r2 << std::endl;
101 | }
102 | 
103 | void f_feed(yielder<void, float> yield, float v)
104 | {
105 | 	BOOST_CHECK(v == 2.1f);
106 | 	std::cout << "v=" << v << std::endl;
107 | 	float a = yield();
108 | 	BOOST_CHECK(a == 98.f);
109 | 	std::cout << "a=" << a << std::endl;
110 | }
111 | 
112 | BOOST_AUTO_TEST_CASE(feed)
113 | {
114 | 	typedef Coroutine<void, float, void (*)(yielder<void, float>, float),
115 | 		1024*8, stack::Default, context> coro_t;
116 | 
117 | 	coro_t c(&f_feed);
118 | 
119 | 	c(2.1f);
120 | 	c(98.f);
121 | }
122 | 
123 | // FUNCTOR
124 | 
125 | struct f_ret_feed_functor {
126 | 
127 | 	int operator()(yielder<int, float> yield, float v)
128 | 	{
129 | 		BOOST_CHECK(v == 2.2f);
130 | 		std::cout << "v=" << v << std::endl;
131 | 		float a = yield(42);
132 | 		BOOST_CHECK(a == 99.f);
133 | 		std::cout << "a=" << a << std::endl;
134 | 		return 84;
135 | 	}
136 | 
137 | };
138 | 
139 | BOOST_AUTO_TEST_CASE(ret_feed_functor)
140 | {
141 | 	typedef Coroutine<int, float, f_ret_feed_functor,
142 | 		1024*8, stack::Default, context> coro_t;
143 | 
144 | 	coro_t c((f_ret_feed_functor())); // copy
145 | 
146 | 	int r1 = c(2.2f);
147 | 	BOOST_CHECK(r1 == 42);
148 | 	std::cout << "r1=" << r1 << std::endl;
149 | 	int r2 = c(99.f);
150 | 	BOOST_CHECK(r2 == 84);
151 | 	std::cout << "r2=" << r2 << std::endl;
152 | }
153 | 
154 | struct f_ret_functor {
155 | 
156 | 	int operator()(yielder<int> yield)
157 | 	{
158 | 		yield(43);
159 | 		return 85;
160 | 	}
161 | 
162 | };
163 | 
164 | BOOST_AUTO_TEST_CASE(ret_functor)
165 | {
166 | 	typedef Coroutine<int, void, f_ret_functor,
167 | 		1024*8, stack::Default, context> coro_t;
168 | 
169 | 	f_ret_functor f;
170 | 	coro_t c(f); // copy
171 | 
172 | 	int r1 = c();
173 | 	BOOST_CHECK(r1 == 43);
174 | 	std::cout << "r1=" << r1 << std::endl;
175 | 	int r2 = c();
176 | 	BOOST_CHECK(r2 == 85);
177 | 	std::cout << "r2=" << r2 << std::endl;
178 | }
179 | 
180 | struct f_feed_functor {
181 | 
182 | 	void operator()(yielder<void, float> yield, float v) const
183 | 	{
184 | 		BOOST_CHECK(v == 2.1f);
185 | 		std::cout << "v=" << v << std::endl;
186 | 		float a = yield();
187 | 		BOOST_CHECK(a == 98.f);
188 | 		std::cout << "a=" << a << std::endl;
189 | 	}
190 | 
191 | };
192 | 
193 | BOOST_AUTO_TEST_CASE(feed_functor)
194 | {
195 | 	typedef Coroutine<void, float, const f_feed_functor&,
196 | 		1024*8, stack::Default, context> coro_t;
197 | 
198 | 	f_feed_functor f;
199 | 	coro_t c(f); // const ref
200 | 
201 | 	c(2.1f);
202 | 	c(98.f);
203 | }
204 | 
205 | #endif
206 | 


--------------------------------------------------------------------------------
/tests/context/context.cpp.inc:
--------------------------------------------------------------------------------
  1 | /* vim: ft=cpp
  2 |  * context.inc.cpp
  3 |  * Copyright © 2010 François-Xavier 'Bombela' Bourlet <bombela@gmail.com>
  4 |  *
  5 | */
  6 | 
  7 | #include <test.hpp>
  8 | #include <iostream>
  9 | #include <coroutine/impl/stack_dynamic.hpp>
 10 | #include <coroutine/impl/stack_static.hpp>
 11 | 
 12 | using namespace coroutine;
 13 | 
 14 | static const size_t stack_size = 8 * 1024 * 1024;
 15 | typedef stack::stack<stack::dynamic, stack_size> stack_t;
 16 | typedef context::context<
 17 | 	context::resolve_alias<context_tag>::type
 18 | 	, stack_t> context_t;
 19 | 
 20 | void function(void*) {}
 21 | 
 22 | BOOST_AUTO_TEST_CASE(test_compile)
 23 | {
 24 | 	context_t context(&function, 0);
 25 | 	BOOST_CHECK_EQUAL(42, 42);
 26 | }
 27 | 
 28 | struct TestExecution
 29 | {
 30 | 	bool executed;
 31 | 	TestExecution(): executed(false) { }
 32 | 	virtual void operator()() { executed = true; }
 33 | 
 34 | 	static void dotest(void* te) {
 35 | 		(*(TestExecution*)(te))();
 36 | 	}
 37 | };
 38 | 
 39 | template <typename Context>
 40 | struct TestYield: TestExecution
 41 | {
 42 |     Context context;
 43 | 	TestYield(): context(&TestYield::dotest, this) {}
 44 | 	void operator()()
 45 | 	{
 46 | 		TestExecution::operator()();
 47 | 		context.leave();
 48 | 		BOOST_ERROR("yield passed");
 49 | 	}
 50 | };
 51 | 
 52 | BOOST_AUTO_TEST_CASE(execution_and_yield)
 53 | {
 54 | 	TestYield< context_t > test;
 55 | 	test.context.enter();
 56 | 	BOOST_CHECK(test.executed);
 57 | }
 58 | 
 59 | template <typename Context>
 60 | struct LotOfStack: TestYield<Context>
 61 | {
 62 | 	void operator()() __attribute__ ((noinline))
 63 | 	{
 64 | 		TestYield<Context>::operator()();
 65 | 		UNUSED char data[1024*40];
 66 | 		data[0] = 42;
 67 | 	}
 68 | };
 69 | 
 70 | BOOST_AUTO_TEST_CASE(uselotofstack)
 71 | {
 72 | 	LotOfStack<context_t> test;
 73 | 	test.context.enter();
 74 | 	BOOST_CHECK(test.executed);
 75 | }
 76 | 
 77 | 
 78 | template <typename Context>
 79 | struct TestYieldInfinite
 80 | {
 81 |     Context context;
 82 | 	int cnt;
 83 | 	TestYieldInfinite(): context(&TestYieldInfinite::dotest, this), cnt(0) {}
 84 | 	void operator()()
 85 | 	{
 86 | 		while (42) {
 87 | 			++cnt;
 88 | 			context.leave();
 89 | 		}
 90 | 	}
 91 | 	static void dotest(void* te) {
 92 | 		(*(TestYieldInfinite*)(te))();
 93 | 	}
 94 | };
 95 | 
 96 | BOOST_AUTO_TEST_CASE(enter_leave_few_times)
 97 | {
 98 | 	TestYieldInfinite<context_t> tester;
 99 | 
100 | 	for (int i = 0; i < 42; ++i)
101 | 	{
102 | 		BOOST_CHECK_EQUAL(tester.cnt, i);
103 |         tester.context.enter();
104 | 		BOOST_CHECK_EQUAL(tester.cnt, i + 1);
105 | 	}
106 | }
107 | 
108 | template <typename Context>
109 | struct TestYieldInfinite2
110 | {
111 | 	int cnt;
112 | 	Context* volatile used;
113 | 	void operator()()
114 | 	{
115 | 		while (42) {
116 | 			++cnt;
117 | 			used->leave();
118 | 		}
119 | 	}
120 | 	static void dotest(void* te) {
121 | 		(*(TestYieldInfinite2*)(te))();
122 | 	}
123 | };
124 | 
125 | BOOST_AUTO_TEST_CASE(move_context_with_dynamic_stack)
126 | {
127 | 	typedef TestYieldInfinite2<context_t> tester_t;
128 | 	tester_t tester;
129 | 	context_t a(&tester.dotest, &tester);
130 | 	tester.cnt = 0;
131 | 	tester.used = &a;
132 | 
133 | 	BOOST_CHECK(tester.cnt == 0);
134 | 	a.enter();
135 | 	BOOST_CHECK(tester.cnt == 1);
136 | 
137 | 	context_t b = std::move(a);
138 | 	tester.used = &b;
139 | 	b.enter();
140 | 	BOOST_CHECK(tester.cnt == 2);
141 | }
142 | 
143 | BOOST_AUTO_TEST_CASE(move_context_with_static_stack)
144 | {
145 | 	typedef stack::stack<stack::static_, 1024 * 4> stack_t;
146 | 	typedef context::context<
147 | 	context::resolve_alias<context_tag>::type
148 | 	, stack_t> context_t;
149 | 
150 | 	typedef TestYieldInfinite2<context_t> tester_t;
151 | 	tester_t tester;
152 | 	context_t a(&tester.dotest, &tester);
153 | 	tester.cnt = 0;
154 | 	tester.used = &a;
155 | 
156 | 	BOOST_CHECK(tester.cnt == 0);
157 | 	a.enter();
158 | 	BOOST_CHECK(tester.cnt == 1);
159 | 	a.reset();
160 | 	a.enter();
161 | 	BOOST_CHECK(tester.cnt == 2);
162 | 	a.enter();
163 | 	a.reset();
164 | 	a.enter();
165 | 	BOOST_CHECK(tester.cnt == 4);
166 | 
167 | 	context_t b = std::move(a);
168 | 	b.reset();
169 | 	tester.used = &b;
170 | 	b.enter();
171 | 	BOOST_CHECK(tester.cnt == 5);
172 | 	b.enter();
173 | 	b.enter();
174 | 	BOOST_CHECK(tester.cnt == 7);
175 | }
176 | 
177 | void somefunc(int v) {
178 | //    std::cout << "hey some func! " << v << std::endl;
179 | 	if (v)
180 | 		somefunc(v - 1);
181 | }
182 | 
183 | template <typename Context>
184 | struct TestSubCall
185 | {
186 | 	int cnt;
187 | 	Context* volatile used;
188 | 	void (*f)(int);
189 | 
190 | 	void operator()()
191 | 	{
192 | 		while (42) {
193 | 			++cnt;
194 | 			this->f(42);
195 | 			used->leave();
196 | 		}
197 | 	}
198 | 	static void dotest(void* te) {
199 | 		(*(TestSubCall*)(te))();
200 | 	}
201 | };
202 | 
203 | BOOST_AUTO_TEST_CASE(test_with_subfunc_call)
204 | {
205 | 	typedef stack::stack<stack::dynamic, 1024 * 32> stack_t;
206 | 	typedef context::context<
207 | 	context::resolve_alias<context_tag>::type
208 | 	, stack_t> context_t;
209 | 
210 | 	typedef TestSubCall<context_t> tester_t;
211 | 	tester_t tester;
212 | 	context_t a(&tester.dotest, &tester);
213 | 	tester.cnt = 0;
214 | 	tester.used = &a;
215 | 	tester.f = &somefunc;
216 | 	a.enter();
217 | }
218 | 


--------------------------------------------------------------------------------