Initial revision

.gitignore

+*.pyc
+*.pyo
+*.cpp
+*.so
+/build/
+/dist/

COPYING

+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

Makefile

+.PHONY: all cython_module run
+
+all: cython_module
+
+cython_module:
+	python3 setup.py build_ext --inplace
+
+run: cython_module
+	python3 -c "import lwan_coro; lwan_coro.main()"

lwan/lwan-array.c

+/*
+ * lwan - simple web server
+ * Copyright (c) 2017 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+#include "lwan-array.h"
+
+#define INCREMENT 16
+
+int
+lwan_array_init(struct lwan_array *a)
+{
+    if (UNLIKELY(!a))
+        return -EINVAL;
+
+    a->base = NULL;
+    a->elements = 0;
+
+    return 0;
+}
+
+int
+lwan_array_reset(struct lwan_array *a)
+{
+    if (UNLIKELY(!a))
+        return -EINVAL;
+
+    free(a->base);
+    a->base = NULL;
+    a->elements = 0;
+
+    return 0;
+}
+
+
+#if !defined (HAS_REALLOCARRAY)
+
+#if !defined(HAVE_BUILTIN_MUL_OVERFLOW)
+/*
+ * This is sqrt(SIZE_MAX+1), as s1*s2 <= SIZE_MAX
+ * if both s1 < MUL_NO_OVERFLOW and s2 < MUL_NO_OVERFLOW
+ */
+#define MUL_NO_OVERFLOW	((size_t)1 << (sizeof(size_t) * 4))
+
+static inline bool umull_overflow(size_t a, size_t b, size_t *out)
+{
+    if ((a >= MUL_NO_OVERFLOW || b >= MUL_NO_OVERFLOW) && a > 0 && SIZE_MAX / a < b)
+        return true;
+    *out = a * b;
+    return false;
+}
+#else
+#define umull_overflow __builtin_mul_overflow
+#endif
+
+void *reallocarray(void *optr, size_t nmemb, size_t size)
+{
+    size_t total_size;
+    if (UNLIKELY(umull_overflow(nmemb, size, &total_size))) {
+        errno = ENOMEM;
+        return NULL;
+    }
+    return realloc(optr, total_size);
+}
+
+#endif /* HAS_REALLOCAARRAY */ 
+
+
+#if !defined(HAVE_BUILTIN_ADD_OVERFLOW)
+static inline bool add_overflow(size_t a, size_t b, size_t *out)
+{
+    if (UNLIKELY(a > 0 && b > SIZE_MAX - a))
+        return true;
+
+    *out = a + INCREMENT;
+    return false;
+}
+#else
+#define add_overflow __builtin_add_overflow
+#endif
+
+
+void *
+lwan_array_append(struct lwan_array *a, size_t element_size)
+{
+    if (!(a->elements % INCREMENT)) {
+        void *new_base;
+        size_t new_cap;
+
+        if (UNLIKELY(add_overflow(a->elements, INCREMENT, &new_cap))) {
+            errno = EOVERFLOW;
+            return NULL;
+        }
+
+        new_base = reallocarray(a->base, new_cap, element_size);
+        if (UNLIKELY(!new_base))
+            return NULL;
+
+        a->base = new_base;
+    }
+
+    return ((unsigned char *)a->base) + a->elements++ * element_size;
+}
+
+void
+lwan_array_sort(struct lwan_array *a, size_t element_size, int (*cmp)(const void *a, const void *b))
+{
+    if (LIKELY(a->elements))
+        qsort(a->base, a->elements - 1, element_size, cmp);
+}
+
+static void
+coro_lwan_array_free(void *data)
+{
+    struct lwan_array *array = data;
+
+    lwan_array_reset(array);
+    free(array);
+}
+
+struct lwan_array *
+coro_lwan_array_new(struct coro *coro)
+{
+    struct lwan_array *array;
+
+    array = coro_malloc_full(coro, sizeof(*array), coro_lwan_array_free);
+    if (LIKELY(array))
+        lwan_array_init(array);
+
+    return array;
+}

lwan/lwan-array.h

+/*
+ * lwan - simple web server
+ * Copyright (c) 2017 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#include "lwan-coro.h"
+
+struct lwan_array {
+    void *base;
+    size_t elements;
+};
+
+int lwan_array_init(struct lwan_array *a);
+int lwan_array_reset(struct lwan_array *a);
+void *lwan_array_append(struct lwan_array *a, size_t element_size);
+void lwan_array_sort(struct lwan_array *a, size_t element_size, int (*cmp)(const void *a, const void *b));
+struct lwan_array *coro_lwan_array_new(struct coro *coro);
+
+#define LIKELY_IS(x,y)        __builtin_expect((x), (y))
+#define LIKELY(x)       LIKELY_IS(!!(x), 1)
+#define UNLIKELY(x)     LIKELY_IS((x), 0)
+
+#define DEFINE_ARRAY_TYPE(array_type_, element_type_) \
+    struct array_type_ { \
+        struct lwan_array base; \
+    }; \
+    __attribute__((unused)) \
+    static inline int array_type_ ## _init(struct array_type_ *array) \
+    { \
+        return lwan_array_init((struct lwan_array *)array); \
+    } \
+    __attribute__((unused)) \
+    static inline int array_type_ ## _reset(struct array_type_ *array) \
+    { \
+        return lwan_array_reset((struct lwan_array *)array); \
+    } \
+    __attribute__((unused)) \
+    static inline element_type_ * array_type_ ## _append(struct array_type_ *array) \
+    { \
+        return (element_type_ *)lwan_array_append((struct lwan_array *)array, sizeof(element_type_)); \
+    } \
+    __attribute__((unused)) \
+    static inline void array_type_ ## _sort(struct array_type_ *array, int (*cmp)(const void *a, const void *b)) \
+    { \
+        lwan_array_sort((struct lwan_array *)array, sizeof(element_type_), cmp); \
+    } \
+    __attribute__((unused)) \
+    static inline struct array_type_ *coro_ ## array_type_ ## _new(struct coro *coro) \
+    { \
+        return (struct array_type_ *)coro_lwan_array_new(coro); \
+    }
+
+
+#if defined (__cplusplus)
+}
+#endif

lwan/lwan-coro.c

+/*
+ * lwan - simple web server
+ * Copyright (c) 2012 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#define _GNU_SOURCE
+#include <assert.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+//#include "lwan-private.h"
+
+#include "lwan-array.h"
+#include "lwan-coro.h"
+
+#ifdef USE_VALGRIND
+#include <valgrind/valgrind.h>
+#endif
+
+#define CORO_STACK_MIN         ((3 * (PTHREAD_STACK_MIN)) / 2)
+
+static_assert(DEFAULT_BUFFER_SIZE < (CORO_STACK_MIN + PTHREAD_STACK_MIN),
+    "Request buffer fits inside coroutine stack");
+
+typedef void (*defer_func)();
+
+struct coro_defer {
+    defer_func func;
+    void *data1;
+    void *data2;
+};
+
+DEFINE_ARRAY_TYPE(coro_defer_array, struct coro_defer)
+
+struct coro {
+    struct coro_switcher *switcher;
+    coro_context context;
+    struct coro_defer_array defer;
+
+    int yield_value;
+
+#if !defined(NDEBUG) && defined(USE_VALGRIND)
+    unsigned int vg_stack_id;
+#endif
+
+    bool ended;
+};
+
+#if defined(__APPLE__)
+#define ASM_SYMBOL(name_) "_" #name_
+#else
+#define ASM_SYMBOL(name_) #name_
+#endif
+
+#define ASM_ROUTINE(name_) ".globl " ASM_SYMBOL(name_) "\n\t" ASM_SYMBOL(name_) ":\n\t"
+
+/*
+ * This swapcontext() implementation was obtained from glibc and modified
+ * slightly to not save/restore the floating point registers, unneeded
+ * registers, and signal mask.  It is Copyright (C) 2001, 2002, 2003 Free
+ * Software Foundation, Inc and are distributed under GNU LGPL version 2.1
+ * (or later).  I'm not sure if I can distribute them inside a GPL program;
+ * they're straightforward so I'm assuming there won't be any problem; if
+ * there is, I'll just roll my own.
+ *     -- Leandro
+ */
+#if defined(__x86_64__)
+void __attribute__((noinline, visibility("internal")))
+coro_swapcontext(coro_context *current, coro_context *other);
+    asm(
+    ".text\n\t"
+    ".p2align 4\n\t"
+    ASM_ROUTINE(coro_swapcontext)
+    "mov    %rbx,0(%rdi)\n\t"
+    "mov    %rbp,8(%rdi)\n\t"
+    "mov    %r12,16(%rdi)\n\t"
+    "mov    %r13,24(%rdi)\n\t"
+    "mov    %r14,32(%rdi)\n\t"
+    "mov    %r15,40(%rdi)\n\t"
+    "mov    %rdi,48(%rdi)\n\t"
+    "mov    %rsi,56(%rdi)\n\t"
+    "mov    (%rsp),%rcx\n\t"
+    "mov    %rcx,64(%rdi)\n\t"
+    "lea    0x8(%rsp),%rcx\n\t"
+    "mov    %rcx,72(%rdi)\n\t"
+    "mov    72(%rsi),%rsp\n\t"
+    "mov    0(%rsi),%rbx\n\t"
+    "mov    8(%rsi),%rbp\n\t"
+    "mov    16(%rsi),%r12\n\t"
+    "mov    24(%rsi),%r13\n\t"
+    "mov    32(%rsi),%r14\n\t"
+    "mov    40(%rsi),%r15\n\t"
+    "mov    48(%rsi),%rdi\n\t"
+    "mov    64(%rsi),%rcx\n\t"
+    "mov    56(%rsi),%rsi\n\t"
+    "jmp    *%rcx\n\t");
+#elif defined(__i386__)
+void __attribute__((noinline, visibility("internal")))
+coro_swapcontext(coro_context *current, coro_context *other);
+    asm(
+    ".text\n\t"
+    ".p2align 16\n\t"
+    ASM_ROUTINE(coro_swapcontext)
+    "movl   0x4(%esp),%eax\n\t"
+    "movl   %ecx,0x1c(%eax)\n\t" /* ECX */
+    "movl   %ebx,0x0(%eax)\n\t"  /* EBX */
+    "movl   %esi,0x4(%eax)\n\t"  /* ESI */
+    "movl   %edi,0x8(%eax)\n\t"  /* EDI */
+    "movl   %ebp,0xc(%eax)\n\t"  /* EBP */
+    "movl   (%esp),%ecx\n\t"
+    "movl   %ecx,0x14(%eax)\n\t" /* EIP */
+    "leal   0x4(%esp),%ecx\n\t"
+    "movl   %ecx,0x18(%eax)\n\t" /* ESP */
+    "movl   8(%esp),%eax\n\t"
+    "movl   0x14(%eax),%ecx\n\t" /* EIP (1) */
+    "movl   0x18(%eax),%esp\n\t" /* ESP */
+    "pushl  %ecx\n\t"            /* EIP (2) */
+    "movl   0x0(%eax),%ebx\n\t"  /* EBX */
+    "movl   0x4(%eax),%esi\n\t"  /* ESI */
+    "movl   0x8(%eax),%edi\n\t"  /* EDI */
+    "movl   0xc(%eax),%ebp\n\t"  /* EBP */
+    "movl   0x1c(%eax),%ecx\n\t" /* ECX */
+    "ret\n\t");
+#else
+#define coro_swapcontext(cur,oth) swapcontext(cur, oth)
+#endif
+
+#ifndef __x86_64__
+static void
+coro_entry_point(struct coro *coro, coro_function_t func, void *data)
+{
+    int return_value = func(coro, data);
+    coro->ended = true;
+    coro_yield(coro, return_value);
+}
+#else
+void coro_entry_point(struct coro *coro, coro_function_t func, void *data);
+    asm(
+    ".text\n\t"
+    ".p2align 4\n\t"
+    ASM_ROUTINE(coro_entry_point)
+    "pushq %rbx\n\t"
+    "movq  %rdi, %rbx\n\t"		/* coro = rdi */
+    "movq  %rsi, %rdx\n\t"		/* func = rsi */
+    "movq  %r15, %rsi\n\t"		/* data = r15 */
+    "call  *%rdx\n\t"			/* eax = func(coro, data) */
+    "movq  (%rbx), %rsi\n\t"
+    "movb  $1, 0x6c(%rbx)\n\t"		/* coro->ended = true */
+    "movl  %eax, 0x68(%rbx)\n\t"	/* coro->yield_value = eax */
+    "popq  %rbx\n\t"
+    "leaq  0x50(%rsi), %rdi\n\t"	/* get coro context from coro */
+    "jmp   " ASM_SYMBOL(coro_swapcontext) "\n\t");
+#endif
+
+void
+coro_deferred_run(struct coro *coro, size_t generation)
+{
+    struct lwan_array *array = (struct lwan_array *)&coro->defer;
+    struct coro_defer *defers = array->base;
+    size_t i;
+
+    for (i = array->elements; i != generation; i--) {
+        struct coro_defer *defer = &defers[i - 1];
+
+        defer->func(defer->data1, defer->data2);
+    }
+
+    array->elements = generation;
+}
+
+size_t
+coro_deferred_get_generation(const struct coro *coro)
+{
+    const struct lwan_array *array = (struct lwan_array *)&coro->defer;
+
+    return array->elements;
+}
+
+void
+coro_reset(struct coro *coro, coro_function_t func, void *data)
+{
+    unsigned char *stack = (unsigned char *)(coro + 1);
+
+    coro->ended = false;
+
+    coro_deferred_run(coro, 0);
+    coro_defer_array_reset(&coro->defer);
+
+#if defined(__x86_64__)
+    /* coro_entry_point() for x86-64 has 3 arguments, but RDX isn't
+     * stored.  Use R15 instead, and implement the trampoline
+     * function in assembly in order to use this register when
+     * calling the user function. */
+    coro->context[5 /* R15 */] = (uintptr_t) data;
+    coro->context[6 /* RDI */] = (uintptr_t) coro;
+    coro->context[7 /* RSI */] = (uintptr_t) func;
+    coro->context[8 /* RIP */] = (uintptr_t) coro_entry_point;
+
+    /* Ensure stack is properly aligned: it should be aligned to a
+     * 16-bytes boundary so SSE will work properly, but should be
+     * aligned on an 8-byte boundary right after calling a function. */
+    uintptr_t rsp = (uintptr_t) stack + CORO_STACK_MIN;
+    coro->context[9 /* RSP */] = (rsp & ~0xful) - 0x8ul;
+#elif defined(__i386__)
+    stack = (unsigned char *)(uintptr_t)(stack + CORO_STACK_MIN);
+
+    /* Make room for 3 args */
+    stack -= sizeof(uintptr_t) * 3;
+    /* Ensure 4-byte alignment */
+    stack = (unsigned char*)((uintptr_t)stack & (uintptr_t)~0x3);
+
+    uintptr_t *argp = (uintptr_t *)stack;
+    *argp++ = 0;
+    *argp++ = (uintptr_t)coro;
+    *argp++ = (uintptr_t)func;
+    *argp++ = (uintptr_t)data;
+
+    coro->context[5 /* EIP */] = (uintptr_t) coro_entry_point;
+    coro->context[6 /* ESP */] = (uintptr_t) stack;
+#else
+    getcontext(&coro->context);
+
+    coro->context.uc_stack.ss_sp = stack;
+    coro->context.uc_stack.ss_size = CORO_STACK_MIN;
+    coro->context.uc_stack.ss_flags = 0;
+    coro->context.uc_link = NULL;
+
+    makecontext(&coro->context, (void (*)())coro_entry_point, 3,
+        coro, func, data);
+#endif
+}
+
+ALWAYS_INLINE void
+coro_update(struct coro *coro, struct coro_switcher *new_switcher)
+{
+    assert(coro);
+    assert(coro->ended == false);
+
+    coro->switcher = new_switcher;
+}
+
+ALWAYS_INLINE struct coro *
+coro_new(struct coro_switcher *switcher, coro_function_t function, void *data)
+{
+    struct coro *coro = malloc(sizeof(*coro) + CORO_STACK_MIN);
+    if (UNLIKELY(!coro))
+        return NULL;
+
+    if (UNLIKELY(coro_defer_array_init(&coro->defer) < 0)) {
+        free(coro);
+        return NULL;
+    }
+
+    coro->switcher = switcher;
+    coro_reset(coro, function, data);
+
+#if !defined(NDEBUG) && defined(USE_VALGRIND)
+    char *stack = (char *)(coro + 1);
+    coro->vg_stack_id = VALGRIND_STACK_REGISTER(stack, stack + CORO_STACK_MIN);
+#endif
+
+    return coro;
+}
+
+ALWAYS_INLINE int
+coro_resume(struct coro *coro)
+{
+    assert(coro);
+    assert(coro->ended == false);
+
+#if defined(__x86_64__) || defined(__i386__)
+    coro_swapcontext(&coro->switcher->caller, &coro->context);
+    if (!coro->ended)
+        memcpy(&coro->context, &coro->switcher->callee,
+                    sizeof(coro->context));
+#else
+    coro_context prev_caller;
+
+    memcpy(&prev_caller, &coro->switcher->caller, sizeof(prev_caller));
+    coro_swapcontext(&coro->switcher->caller, &coro->context);
+    if (!coro->ended) {
+        memcpy(&coro->context, &coro->switcher->callee,
+                    sizeof(coro->context));
+        memcpy(&coro->switcher->caller, &prev_caller,
+                    sizeof(coro->switcher->caller));
+    }
+#endif
+
+    return coro->yield_value;
+}
+
+ALWAYS_INLINE int
+coro_resume_value(struct coro *coro, int value)
+{
+    assert(coro);
+    assert(coro->ended == false);
+
+    coro->yield_value = value;
+    return coro_resume(coro);
+}
+
+ALWAYS_INLINE int
+coro_yield(struct coro *coro, int value)
+{
+    assert(coro);
+    coro->yield_value = value;
+    coro_swapcontext(&coro->switcher->callee, &coro->switcher->caller);
+    return coro->yield_value;
+}
+
+void
+coro_free(struct coro *coro)
+{
+    assert(coro);
+#if !defined(NDEBUG) && defined(USE_VALGRIND)
+    VALGRIND_STACK_DEREGISTER(coro->vg_stack_id);
+#endif
+    coro_deferred_run(coro, 0);
+    coro_defer_array_reset(&coro->defer);
+    free(coro);
+}
+
+static void
+coro_defer_any(struct coro *coro, defer_func func, void *data1, void *data2)
+{
+    struct coro_defer *defer;
+
+    assert(func);
+
+    defer = coro_defer_array_append(&coro->defer);
+    if (UNLIKELY(!defer)) {
+        //lwan_status_error("Could not add new deferred function for coro %p", coro);
+        return;
+    }
+
+    defer->func = func;
+    defer->data1 = data1;
+    defer->data2 = data2;
+}
+
+ALWAYS_INLINE void
+coro_defer(struct coro *coro, void (*func)(void *data), void *data)
+{
+    coro_defer_any(coro, func, data, NULL);
+}
+
+ALWAYS_INLINE void
+coro_defer2(struct coro *coro, void (*func)(void *data1, void *data2),
+            void *data1, void *data2)
+{
+    coro_defer_any(coro, func, data1, data2);
+}
+
+void *
+coro_malloc_full(struct coro *coro, size_t size, void (*destroy_func)())
+{
+    void *ptr = malloc(size);
+
+    if (LIKELY(ptr))
+        coro_defer(coro, destroy_func, ptr);
+
+    return ptr;
+}
+
+inline void *
+coro_malloc(struct coro *coro, size_t size)
+{
+    return coro_malloc_full(coro, size, free);
+}
+
+char *
+coro_strndup(struct coro *coro, const char *str, size_t max_len)
+{
+    const size_t len = max_len + 1;
+    char *dup = coro_malloc(coro, len);
+    if (LIKELY(dup)) {
+        memcpy(dup, str, len);
+        dup[len - 1] = '\0';
+    }
+    return dup;
+}
+
+char *
+coro_strdup(struct coro *coro, const char *str)
+{
+    return coro_strndup(coro, str, strlen(str));
+}
+
+char *
+coro_printf(struct coro *coro, const char *fmt, ...)
+{
+    va_list values;
+    int len;
+    char *tmp_str;
+
+    va_start(values, fmt);
+    len = vasprintf(&tmp_str, fmt, values);
+    va_end(values);
+
+    if (UNLIKELY(len < 0))
+        return NULL;
+
+    coro_defer(coro, CORO_DEFER(free), tmp_str);
+    return tmp_str;
+}

lwan/lwan-coro.h

+/*
+ * lwan - simple web server
+ * Copyright (c) 2012 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#pragma once
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include <stddef.h>
+#if defined(__x86_64__)
+#include <stdint.h>
+typedef uintptr_t coro_context[10];
+#elif defined(__i386__)
+#include <stdint.h>
+typedef uintptr_t coro_context[7];
+#else
+#include <ucontext.h>
+typedef ucontext_t coro_context;
+#endif
+
+#define DEFAULT_BUFFER_SIZE 4096
+#define ALWAYS_INLINE inline __attribute__((always_inline))
+
+struct coro;
+typedef struct coro coro_t;
+
+typedef int    (*coro_function_t)	(struct coro *coro, void *data);
+
+typedef struct coro_switcher {
+    coro_context caller;
+    coro_context callee;
+}coro_switcher_t;
+
+struct coro *coro_new(struct coro_switcher *switcher, coro_function_t function, void *data);
+void	coro_free(struct coro *coro);
+
+void    coro_reset(struct coro *coro, coro_function_t func, void *data);
+void    coro_update(struct coro *coro, struct coro_switcher *new_switcher);
+
+int	coro_resume(struct coro *coro);
+int	coro_resume_value(struct coro *coro, int value);
+int	coro_yield(struct coro *coro, int value);
+
+void    coro_defer(struct coro *coro, void (*func)(void *data), void *data);
+void    coro_defer2(struct coro *coro, void (*func)(void *data1, void *data2),
+            void *data1, void *data2);
+
+void    coro_deferred_run(struct coro *coro, size_t generation);
+size_t  coro_deferred_get_generation(const struct coro *coro);
+
+void   *coro_malloc(struct coro *coro, size_t sz)
+            __attribute__((malloc));
+void   *coro_malloc_full(struct coro *coro, size_t size, void (*destroy_func)())
+            __attribute__((malloc));
+char   *coro_strdup(struct coro *coro, const char *str);
+char   *coro_strndup(struct coro *coro, const char *str, size_t len);
+char   *coro_printf(struct coro *coro, const char *fmt, ...);
+
+#define CORO_DEFER(fn)		((void (*)(void *))(fn))
+#define CORO_DEFER2(fn)		((void (*)(void *, void *))(fn))
+
+#if defined (__cplusplus)
+}
+#endif

setup.py

+from distutils.core import setup
+from distutils.extension import Extension
+from Cython.Build import cythonize
+
+setup(
+  ext_modules = cythonize([
+    Extension("lwan_coro",
+              language="c++",
+              sources=["wrapper.pyx", "lwan/lwan-array.c" ,"lwan/lwan-coro.c"],
+              extra_compile_args=["-pthread"],
+              extra_link_args=["-pthread"]
+    )
+  ])
+)

wrapper.pyx

+from libc.stdlib cimport exit, calloc, free, rand
+from libc.stdio cimport printf, fprintf, stderr
+from libc.string cimport memset
+from posix.unistd cimport usleep, sysconf
+
+cdef extern from "<unistd.h>" nogil:
+  enum: _SC_NPROCESSORS_ONLN # Seems to no be included in "posix.unistd".
+
+from libcpp.deque cimport deque
+ctypedef deque[coro_t *] coro_deque_t
+
+from libc.time cimport CLOCKS_PER_SEC, clock_t, clock
+
+cdef extern from "lwan/lwan-coro.h" nogil:
+  ctypedef struct coro_switcher_t:
+    pass
+  ctypedef struct coro_t:
+    coro_switcher_t *switcher
+
+  ctypedef int (*coro_function_t) (coro_t *, void *)
+
+  void coro_reset(coro_t *, coro_function_t, void *)
+  coro_t *coro_new(coro_switcher_t *, coro_function_t, void *)
+  void coro_free(coro_t *)
+  int coro_resume(coro_t *)
+  int coro_resume_value(coro_t *, int)
+  int coro_yield(coro_t *, int)
+
+  void coro_update(coro_t *, coro_switcher_t *)
+
+cdef enum coro_yield_value:
+  ABORT = -1,
+  MAY_RESUME = 0,
+  FINISHED = 1
+
+cdef extern from "<sys/types.h>" nogil:
+  ctypedef long unsigned int pthread_t
+
+  ctypedef union pthread_attr_t:
+    pass
+  ctypedef union pthread_mutex_t:
+    pass
+  ctypedef union pthread_mutexattr_t:
+    pass
+  ctypedef union pthread_barrier_t:
+    pass
+  ctypedef union pthread_barrierattr_t:
+    pass
+
+cdef extern from "<pthread.h>" nogil:
+  int pthread_create(pthread_t *, const pthread_attr_t *, void *(*)(void *), void *)
+  void pthread_exit(void *)
+  int pthread_join(pthread_t, void **)  
+  int pthread_attr_init(pthread_attr_t *)
+  int pthread_attr_setdetachstate(pthread_attr_t *, int)
+  int pthread_attr_destroy(pthread_attr_t *)
+
+  int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *)
+  int pthread_mutex_destroy(pthread_mutex_t *)
+  int pthread_mutex_lock(pthread_mutex_t *)
+  int pthread_mutex_unlock(pthread_mutex_t *)
+  int pthread_mutex_trylock(pthread_mutex_t *)
+
+  int pthread_barrier_init(pthread_barrier_t *, const pthread_barrierattr_t *, unsigned int)
+  int pthread_barrier_destroy(pthread_barrier_t *)
+  int pthread_barrier_wait(pthread_barrier_t *)
+
+  enum: PTHREAD_CREATE_JOINABLE
+
+cdef extern from "<semaphore.h>" nogil:
+  ctypedef int sem_t
+
+  int sem_destroy(sem_t *)
+  int sem_getvalue(sem_t *, int *)
+  int sem_init(sem_t *, int, unsigned int)
+  int sem_post(sem_t *)
+  int sem_wait(sem_t *)
+
+cdef struct scheduler_t:
+  worker_t *workers
+  unsigned short num_workers
+  pthread_barrier_t barrier
+  sem_t num_sleeping_workers
+  bint is_done
+
+cdef struct worker_t:
+  scheduler_t *scheduler
+  coro_switcher_t switcher
+  coro_deque_t *deque
+  pthread_t thread
+  pthread_mutex_t mutex
+
+cdef void scheduler_init(scheduler_t *scheduler, unsigned short num_workers=sysconf(_SC_NPROCESSORS_ONLN)) nogil:
+  memset(scheduler, 0, sizeof(scheduler[0]))
+
+  scheduler.num_workers = num_workers
+  scheduler.is_done = False
+
+  sem_init(&scheduler.num_sleeping_workers, 0, 0)
+  
+  scheduler.workers = <worker_t *>calloc(scheduler.num_workers, sizeof(worker_t))
+  if not scheduler.workers:
+    fprintf(stderr, "Could not allocate memory for the workers")
+    exit(-1)
+
+  if pthread_barrier_init(&scheduler.barrier, NULL, scheduler.num_workers + 1):
+    fprintf(stderr, "Could not allocate memory for the barrier")
+    exit(-1)
+
+  cdef unsigned short i
+  for i in range(scheduler.num_workers):
+    worker_init(&scheduler.workers[i], scheduler)
+
+cdef void scheduler_coro_add(scheduler_t *scheduler, coro_function_t task, void *arg) nogil:
+  cdef worker_t *main_worker = scheduler.workers
+  main_worker.deque.push_back(coro_new(&main_worker.switcher, task, arg))
+
+cdef void scheduler_run(scheduler_t *scheduler) nogil:
+  # Wait for all workers and the main thread to be ready.
+  pthread_barrier_wait(&scheduler.barrier)
+
+  cdef int num_sleeping_workers
+  while not scheduler.is_done:
+    sem_getvalue(&scheduler.num_sleeping_workers, &num_sleeping_workers)
+    if num_sleeping_workers == scheduler.num_workers:
+      scheduler.is_done = True
+
+cdef void scheduler_destroy(scheduler_t *scheduler) nogil:
+  cdef unsigned short i
+  for i in range(scheduler.num_workers):
+    pthread_join(scheduler.workers[i].thread, NULL)
+    worker_destroy(&scheduler.workers[i])
+
+  free(scheduler.workers)
+
+  sem_destroy(&scheduler.num_sleeping_workers)
+
+  pthread_barrier_destroy(&scheduler.barrier)
+ 
+cdef void worker_init(worker_t *worker, scheduler_t *scheduler) nogil:
+  memset(worker, 0, sizeof(worker[0]))
+
+  worker.scheduler = scheduler
+
+  worker.deque = new coro_deque_t()
+  if not worker.deque:
+    fprintf(stderr, "Could not allocate memory for the deque\n")
+    exit(-1)
+
+  pthread_mutex_init(&worker.mutex, NULL)
+
+  cdef pthread_attr_t attr
+  if pthread_attr_init(&attr):
+    fprintf(stderr, "pthread_attr_init()\n")
+    exit(-1)
+  
+  if pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE):
+    fprintf(stderr, "pthread_attr_setdetachstate()\n")
+    exit(-1)
+
+  if pthread_create(&worker.thread, &attr, worker_run, worker):
+    fprintf(stderr, "pthread_create()\n")
+    exit(-1)
+
+  if pthread_attr_destroy(&attr):
+    fprintf(stderr, "pthread_attr_destroy()\n")
+    exit(-1)
+
+cdef void *worker_run(void *arg) nogil:
+  cdef:
+    worker_t *worker = <worker_t *>arg
+    coro_t *coroutine = NULL
+
+  # Wait for all workers and the main thread to be ready.
+  pthread_barrier_wait(&worker.scheduler.barrier)
+
+  while not worker.scheduler.is_done:
+    coroutine = worker_coro_get(worker)
+    if coroutine:
+      if coro_resume(coroutine) == coro_yield_value.MAY_RESUME:
+        pthread_mutex_lock(&worker.mutex)
+        worker.deque.push_back(coroutine)
+        pthread_mutex_unlock(&worker.mutex)
+      else:
+        coro_free(coroutine)
+    else:
+      sem_post(&worker.scheduler.num_sleeping_workers)
+      usleep(1000000) # 1 ms (arbitrary)
+      sem_wait(&worker.scheduler.num_sleeping_workers)
+
+  pthread_exit(NULL)
+
+cdef coro_t *worker_coro_get(worker_t *worker) nogil:
+  cdef coro_t *coroutine = NULL
+
+  pthread_mutex_lock(&worker.mutex)
+  if worker.deque.empty():
+    pthread_mutex_unlock(&worker.mutex)
+    coroutine = worker_coro_steal(worker)
+  else:
+    coroutine = worker.deque.front()
+    worker.deque.pop_front()
+    pthread_mutex_unlock(&worker.mutex)
+
+  return coroutine
+
+cdef coro_t *worker_coro_steal(worker_t *thief) nogil:
+  cdef:
+    scheduler_t *scheduler = thief.scheduler
+    worker_t *victim = NULL
+    coro_t *stolen_coroutine = NULL
+    unsigned short i, current_index
+    unsigned short random_offset = rand() % scheduler.num_workers
+
+  for i in range(scheduler.num_workers):
+    current_index = (i + random_offset) % scheduler.num_workers
+    victim = scheduler.workers + current_index
+
+    if victim.deque == thief.deque:
+      continue
+
+    pthread_mutex_lock(&victim.mutex)
+    if not victim.deque.empty():
+      stolen_coroutine = victim.deque.back()
+      victim.deque.pop_back()
+      coro_update(stolen_coroutine, &thief.switcher) # Update coroutine's data about its parent worker/thread.
+      pthread_mutex_unlock(&victim.mutex)
+      return stolen_coroutine
+    pthread_mutex_unlock(&victim.mutex)
+  
+  return NULL
+
+cdef void worker_destroy(worker_t *worker) nogil:
+  pthread_mutex_destroy(&worker.mutex)
+  del worker.deque
+
+def main():
+  cdef:
+    scheduler_t s
+    clock_t begin, end
+    unsigned int i
+
+  with nogil:
+    begin = clock()
+
+    scheduler_init(&s)
+
+    for i in range(500):
+      scheduler_coro_add(&s, task, NULL)
+
+    scheduler_run(&s)
+    scheduler_destroy(&s)
+
+    end = clock()
+    printf("%f\n", <double>(end - begin) / CLOCKS_PER_SEC)
+
+# Example task
+cdef int task(coro_t *coroutine, void *arg) nogil:
+  cdef int a = 5
+  coro_yield(coroutine, coro_yield_value.MAY_RESUME)
+  a *= 2
+  coro_yield(coroutine, coro_yield_value.FINISHED)
+