Index: benchmark/readyQ/rq_bench.hfa =================================================================== --- benchmark/readyQ/rq_bench.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ benchmark/readyQ/rq_bench.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -93,5 +93,5 @@ struct __attribute__((aligned(128))) bench_sem { - struct $thread * volatile ptr; + struct thread$ * volatile ptr; }; @@ -105,5 +105,5 @@ bool wait(bench_sem & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) { if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { @@ -124,5 +124,5 @@ bool post(bench_sem & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) return false; if(expected == 0p) { Index: benchmark/readyQ/transfer.cfa =================================================================== --- benchmark/readyQ/transfer.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ benchmark/readyQ/transfer.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -14,5 +14,5 @@ bool exhaust = false; -$thread * the_main; +thread$ * the_main; thread __attribute__((aligned(128))) MyThread { Index: benchmark/size/size.cfa =================================================================== --- benchmark/size/size.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ benchmark/size/size.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -2,7 +2,7 @@ int main(){ - printf("Coroutine : %zu bytes\n", sizeof( $coroutine )); - printf("Monitor : %zu bytes\n", sizeof( $monitor )); - printf("Thread : %zu bytes\n", sizeof( $thread )); + printf("Coroutine : %zu bytes\n", sizeof( coroutine$ )); + printf("Monitor : %zu bytes\n", sizeof( monitor$ )); + printf("Thread : %zu bytes\n", sizeof( thread$ )); printf("Processor : %zu bytes\n", sizeof( processor )); printf("Cluster : %zu bytes\n", sizeof( cluster )); Index: doc/theses/andrew_beach_MMath/code/CondCatch.java =================================================================== --- doc/theses/andrew_beach_MMath/code/CondCatch.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) +++ doc/theses/andrew_beach_MMath/code/CondCatch.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -0,0 +1,50 @@ +// Conditional Match (or Re-Raise) + +class EmptyException extends Exception {} + +public class CondCatch { + static boolean should_catch = false; + + static void throw_exception() throws EmptyException { + throw new EmptyException(); + } + + static void cond_catch() throws EmptyException { + try { + throw_exception(); + } catch (EmptyException exc) { + if (!should_catch) { + throw exc; + } + } + } + + private static long loop(int times) { + long startTime = System.nanoTime(); + for (int count = 0 ; count < times ; ++count) { + try { + cond_catch(); + } catch (EmptyException exc) { + // ... + } + } + long endTime = System.nanoTime(); + return endTime - startTime; + } + + public static void main(String[] args) { + int times = 1; + if (0 < args.length) { + times = Integer.parseInt(args[0]); + } + if (1 < args.length) { + should_catch = 0 != Integer.parseInt(args[1]); + } + + // Warm-Up: + loop(1000); + + long time = loop(times); + System.out.println("Run-Time (ns): " + time); + } +} Index: c/theses/andrew_beach_MMath/code/CondMatch.java =================================================================== --- doc/theses/andrew_beach_MMath/code/CondMatch.java (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ (revision ) @@ -1,40 +1,0 @@ -// Conditional Match (or Re-Raise) - -class EmptyException extends Exception {} - -public class CondMatch { - static boolean should_catch = false; - - static void throw_exception() throws EmptyException { - throw new EmptyException(); - } - - static void cond_catch() throws EmptyException { - try { - throw_exception(); - } catch (EmptyException exc) { - if (!should_catch) { - throw exc; - } - } - } - - public static void main(String[] args) { - int times = 1; - int total_frames = 1; - if (0 < args.length) { - times = Integer.parseInt(args[0]); - } - if (1 < args.length) { - total_frames = Integer.parseInt(args[1]); - } - - for (int count = 0 ; count < times ; ++count) { - try { - cond_catch(); - } catch (EmptyException exc) { - // ... - } - } - } -} Index: doc/theses/andrew_beach_MMath/code/CrossCatch.java =================================================================== --- doc/theses/andrew_beach_MMath/code/CrossCatch.java (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/CrossCatch.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -4,11 +4,8 @@ public class CrossCatch { - public static void main(String[] args) { - int times = 1; - boolean shouldThrow = false; - if (0 < args.length) { - times = Integer.parseInt(args[0]); - } + private static boolean shouldThrow = false; + private static long loop(int times) { + long startTime = System.nanoTime(); for (int count = 0 ; count < times ; ++count) { try { @@ -20,4 +17,19 @@ } } + long endTime = System.nanoTime(); + return endTime - startTime; + } + + public static void main(String[] args) { + int times = 1; + if (0 < args.length) { + times = Integer.parseInt(args[0]); + } + + // Warm-Up: + loop(1000); + + long time = loop(times); + System.out.println("Run-Time (ns): " + time); } } Index: doc/theses/andrew_beach_MMath/code/CrossFinally.java =================================================================== --- doc/theses/andrew_beach_MMath/code/CrossFinally.java (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/CrossFinally.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -2,11 +2,8 @@ public class CrossFinally { - public static void main(String[] args) { - int times = 1; - boolean shouldThrow = false; - if (0 < args.length) { - times = Integer.parseInt(args[0]); - } + private static boolean shouldThrow = false; + private static long loop(int times) { + long startTime = System.nanoTime(); for (int count = 0 ; count < times ; ++count) { try { @@ -16,4 +13,19 @@ } } + long endTime = System.nanoTime(); + return endTime - startTime; + } + + public static void main(String[] args) { + int times = 1; + if (0 < args.length) { + times = Integer.parseInt(args[0]); + } + + // Warm-Up: + loop(1000); + + long time = loop(times); + System.out.println("Run-Time (ns): " + time); } } Index: doc/theses/andrew_beach_MMath/code/ThrowEmpty.java =================================================================== --- doc/theses/andrew_beach_MMath/code/ThrowEmpty.java (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/ThrowEmpty.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -12,4 +12,17 @@ } + private static long loop(int times, int total_frames) { + long startTime = System.nanoTime(); + for (int count = 0 ; count < times ; ++count) { + try { + unwind_empty(total_frames); + } catch (EmptyException e) { + // ... + } + } + long endTime = System.nanoTime(); + return endTime - startTime; + } + public static void main(String[] args) { int times = 1; @@ -22,11 +35,9 @@ } - for (int count = 0 ; count < times ; ++count) { - try { - unwind_empty(total_frames); - } catch (EmptyException e) { - // ... - } - } + // Warm-Up: + loop(1000, total_frames); + + long time = loop(times, total_frames); + System.out.println("Run-Time (ns): " + time); } } Index: doc/theses/andrew_beach_MMath/code/ThrowFinally.java =================================================================== --- doc/theses/andrew_beach_MMath/code/ThrowFinally.java (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/ThrowFinally.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -13,4 +13,17 @@ } + private static long loop(int times, int total_frames) { + long startTime = System.nanoTime(); + for (int count = 0 ; count < times ; ++count) { + try { + unwind_finally(total_frames); + } catch (EmptyException e) { + // ... + } + } + long endTime = System.nanoTime(); + return endTime - startTime; + } + public static void main(String[] args) { int times = 1; @@ -23,11 +36,9 @@ } - for (int count = 0 ; count < times ; ++count) { - try { - unwind_finally(total_frames); - } catch (EmptyException e) { - // ... - } - } + // Warm-Up: + loop(1000, total_frames); + + long time = loop(times, total_frames); + System.out.println("Run-Time (ns): " + time); } } Index: doc/theses/andrew_beach_MMath/code/ThrowOther.java =================================================================== --- doc/theses/andrew_beach_MMath/code/ThrowOther.java (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/ThrowOther.java (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -24,4 +24,19 @@ } + private static long loop(int times, int total_frames) { + long startTime = System.nanoTime(); + for (int count = 0 ; count < times ; ++count) { + try { + unwind_other(total_frames); + } catch (EmptyException e) { + // ... + } catch (NotRaisedException e) { + // ... + } + } + long endTime = System.nanoTime(); + return endTime - startTime; + } + public static void main(String[] args) { int times = 1; @@ -34,13 +49,9 @@ } - for (int count = 0 ; count < times ; ++count) { - try { - unwind_other(total_frames); - } catch (EmptyException e) { - // ... - } catch (NotRaisedException e) { - // ... - } - } + // Warm-Up: + loop(1000, total_frames); + + long time = loop(times, total_frames); + System.out.println("Run-Time (ns): " + time); } } Index: doc/theses/andrew_beach_MMath/code/cond-catch.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cond-catch.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) +++ doc/theses/andrew_beach_MMath/code/cond-catch.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -0,0 +1,44 @@ +// Conditional Match (or Re-Raise) +#include +#include +#include +#include + +EHM_EXCEPTION(empty_exception)(); + +EHM_VIRTUAL_TABLE(empty_exception, empty_vt); + +bool should_catch = false; + +void throw_exception() { + throw (empty_exception){&empty_vt}; +} + +void cond_catch() { + try { + throw_exception(); + } catch (empty_exception * exc ; should_catch) { + // ... + } +} + +int main(int argc, char * argv[]) { + unsigned int times = 1; + if (1 < argc) { + times = strtol(argv[1], 0p, 10); + } + if (2 < argc) { + should_catch = strtol(argv[2], 0p, 10); + } + + Time start_time = timeHiRes(); + for (unsigned int count = 0 ; count < times ; ++count) { + try { + cond_catch(); + } catch (empty_exception * exc) { + // ... + } + } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; +} Index: doc/theses/andrew_beach_MMath/code/cond-catch.cpp =================================================================== --- doc/theses/andrew_beach_MMath/code/cond-catch.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) +++ doc/theses/andrew_beach_MMath/code/cond-catch.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -0,0 +1,47 @@ +// Conditional Match (or Re-Raise) +#include +#include +#include +#include + +using namespace std::chrono; + +struct EmptyException : public std::exception {}; + +bool should_catch = false; + +void throw_exception() { + throw EmptyException(); +} + +void cond_catch() { + try { + throw_exception(); + } catch (EmptyException & exc) { + if (should_catch) { + throw; + } + } +} + +int main(int argc, char * argv[]) { + unsigned int times = 1; + if (1 < argc) { + times = strtol(argv[1], nullptr, 10); + } + if (2 < argc) { + should_catch = strtol(argv[2], nullptr, 10); + } + + time_point start_time = steady_clock::now(); + for (unsigned int count = 0 ; count < times ; ++count) { + try { + cond_catch(); + } catch (EmptyException &) { + // ... + } + } + time_point end_time = steady_clock::now(); + nanoseconds duration = duration_cast(end_time - start_time); + std::cout << "Run-Time (ns): " << duration.count() << std::endl; +} Index: doc/theses/andrew_beach_MMath/code/cond-fixup.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cond-fixup.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) +++ doc/theses/andrew_beach_MMath/code/cond-fixup.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -0,0 +1,44 @@ +// Conditional Match (or Re-Raise) +#include +#include +#include +#include + +EHM_EXCEPTION(empty_exception)(); + +EHM_VIRTUAL_TABLE(empty_exception, empty_vt); + +bool should_catch = false; + +void throw_exception() { + throw (empty_exception){&empty_vt}; +} + +void cond_catch() { + try { + throw_exception(); + } catch (empty_exception * exc ; should_catch) { + // ... + } +} + +int main(int argc, char * argv[]) { + unsigned int times = 1; + if (1 < argc) { + times = strtol(argv[1], 0p, 10); + } + if (2 < argc) { + should_catch = strtol(argv[2], 0p, 10); + } + + Time start_time = timeHiRes(); + for (unsigned int count = 0 ; count < times ; ++count) { + try { + cond_catch(); + } catch (empty_exception * exc) { + // ... + } + } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; +} Index: c/theses/andrew_beach_MMath/code/cond-match-r.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cond-match-r.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ (revision ) @@ -1,40 +1,0 @@ -// Conditional Match (or Re-Raise) -#include -#include - -EHM_EXCEPTION(empty_exception)(); - -EHM_VIRTUAL_TABLE(empty_exception, empty_vt); - -bool should_catch = false; - -void throw_exception() { - throw (empty_exception){&empty_vt}; -} - -void cond_catch() { - try { - throw_exception(); - } catch (empty_exception * exc ; should_catch) { - // ... - } -} - -int main(int argc, char * argv[]) { - unsigned int times = 1; - unsigned int total_frames = 1; - if (2 < argc) { - times = strtol(argv[1], 0p, 10); - } - if (3 < argc) { - total_frames = strtol(argv[2], 0p, 10); - } - - for (unsigned int count = 0 ; count < times ; ++count) { - try { - cond_catch(); - } catch (empty_exception * exc) { - // ... - } - } -} Index: c/theses/andrew_beach_MMath/code/cond-match.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cond-match.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ (revision ) @@ -1,36 +1,0 @@ -// Conditional Match (or Re-Raise) -#include -#include - -EHM_EXCEPTION(empty_exception)(); - -EHM_VIRTUAL_TABLE(empty_exception, empty_vt); - -bool should_catch = false; - -void throw_exception() { - throw (empty_exception){&empty_vt}; -} - -void cond_catch() { - try { - throw_exception(); - } catch (empty_exception * exc ; should_catch) { - // ... - } -} - -int main(int argc, char * argv[]) { - unsigned int times = 1; - if (2 < argc) { - times = strtol(argv[1], 0p, 10); - } - - for (unsigned int count = 0 ; count < times ; ++count) { - try { - cond_catch(); - } catch (empty_exception * exc) { - // ... - } - } -} Index: c/theses/andrew_beach_MMath/code/cond-match.cpp =================================================================== --- doc/theses/andrew_beach_MMath/code/cond-match.cpp (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ (revision ) @@ -1,40 +1,0 @@ -// Conditional Match (or Re-Raise) -#include -#include - -struct EmptyException : public std::exception {}; - -bool should_catch = false; - -void throw_exception() { - throw EmptyException(); -} - -void cond_catch() { - try { - throw_exception(); - } catch (EmptyException & exc) { - if (should_catch) { - throw; - } - } -} - -int main(int argc, char * argv[]) { - unsigned int times = 1; - unsigned int total_frames = 1; - if (2 < argc) { - times = strtol(argv[1], nullptr, 10); - } - if (3 < argc) { - total_frames = strtol(argv[2], nullptr, 10); - } - - for (unsigned int count = 0 ; count < times ; ++count) { - try { - cond_catch(); - } catch (EmptyException &) { - // ... - } - } -} Index: doc/theses/andrew_beach_MMath/code/cross-catch.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cross-catch.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/cross-catch.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Cross a Try Statement with a Termination Handler +#include #include +#include #include @@ -8,11 +10,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (unsigned int count = 0 ; count < times ; ++count) { try { @@ -22,3 +25,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/cross-catch.cpp =================================================================== --- doc/theses/andrew_beach_MMath/code/cross-catch.cpp (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/cross-catch.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,5 +1,9 @@ // Cross a Try Statement with a Termination Handler +#include +#include #include -#include +#include + +using namespace std::chrono; struct NotRaisedException : public std::exception {}; @@ -7,8 +11,9 @@ int main(int argc, char * argv[]) { unsigned int times = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], nullptr, 10); } + time_point start_time = steady_clock::now(); for (unsigned int count = 0 ; count < times ; ++count) { try { @@ -18,3 +23,6 @@ } } + time_point end_time = steady_clock::now(); + nanoseconds duration = duration_cast(end_time - start_time); + std::cout << "Run-Time (ns): " << duration.count() << std::endl; } Index: doc/theses/andrew_beach_MMath/code/cross-finally.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cross-finally.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/cross-finally.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Cross a Try Statement With Finally Clause +#include #include +#include #include @@ -6,11 +8,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (unsigned int count = 0 ; count < times ; ++count) { try { @@ -20,3 +23,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/cross-resume.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/cross-resume.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/cross-resume.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Cross a Try Statement With Finally Clause +#include #include +#include #include @@ -8,11 +10,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (unsigned int count = 0 ; count < times ; ++count) { try { @@ -22,3 +25,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/resume-detor.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/resume-detor.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/resume-detor.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Throw Across Destructor +#include #include +#include #include @@ -26,11 +28,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -40,3 +43,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/resume-empty.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/resume-empty.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/resume-empty.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Resume Across Empty Function +#include #include +#include #include @@ -9,5 +11,4 @@ void unwind_empty(unsigned int frames) { if (frames) { - unwind_empty(frames - 1); } else { @@ -19,11 +20,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -33,3 +35,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/resume-finally.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/resume-finally.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/resume-finally.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Throw Across Finally +#include #include +#include #include @@ -22,11 +24,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -36,3 +39,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/resume-other.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/resume-other.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/resume-other.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Resume Across Other Handler +#include #include +#include #include @@ -24,11 +26,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -38,3 +41,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/test.sh =================================================================== --- doc/theses/andrew_beach_MMath/code/test.sh (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) +++ doc/theses/andrew_beach_MMath/code/test.sh (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -0,0 +1,108 @@ +#!/usr/bin/env bash + +# Usage: LANGUAGE TEST | -b SOURCE_FILE + +readonly ITERATIONS=1000000 # 1 000 000, one million +readonly STACK_HEIGHT=100 + +# Build Test Programs: +# Mini-Make: TARGET SOURCE COMMAND ARGS... +mmake() ( + if [ ! -e "$1" -o "$1" -ot "$2" ]; then + "${@:3}" + fi +) + +build() ( + case "$1" in + *.cfa) + # Requires a symbolic link. + mmake "${1%.cfa}" "$1" ./cfa "$1" -o "${1%.cfa}" + ;; + *.cpp) + mmake "${1%.cpp}-cpp" "$1" g++ "$1" -o "${1%.cpp}-cpp" + ;; + *.java) + mmake "${1%.java}.class" "$1" javac "$1" + ;; + *) + echo "Don't know how to build:" $1 >&2 + exit 2 + ;; + esac +) + +if [ "-b" = "$1" ]; then + for file in "${@:2}"; do + build $file + done + exit 0 +fi + +# Run Test Programs: +# Used in place of unsupported language/test combinations. +unsupported() { + echo "Run-Time: NA" +} + +case "$2" in +cond-match-all) + CFAT="./cond-catch $ITERATIONS 1" + CFAR="./cond-fixup $ITERATIONS 1" + CPP="./cond-catch-cpp $ITERATIONS 1" + JAVA="java CondCatch $ITERATIONS 1" + ;; +cond-match-none) + CFAT="./cond-catch $ITERATIONS 0" + CFAR="./cond-fixup $ITERATIONS 0" + CPP="./cond-catch-cpp $ITERATIONS 0" + JAVA="java CondCatch $ITERATIONS 0" + ;; +cross-catch) + CFAT="./cross-catch $ITERATIONS" + CFAR="./cross-resume $ITERATIONS" + CPP="./cross-catch-cpp $ITERATIONS" + JAVA="java CrossCatch $ITERATIONS" + ;; +cross-finally) + CFAT="./cross-finally $ITERATIONS" + CFAR=unsupported + CPP=unsupported + JAVA="java CrossFinally $ITERATIONS" + ;; +raise-detor) + CFAT="./throw-detor $ITERATIONS $STACK_HEIGHT" + CFAR="./resume-detor $ITERATIONS $STACK_HEIGHT" + CPP="./throw-detor-cpp $ITERATIONS $STACK_HEIGHT" + JAVA=unsupported + ;; +raise-empty) + CFAT="./throw-empty $ITERATIONS $STACK_HEIGHT" + CFAR="./resume-empty $ITERATIONS $STACK_HEIGHT" + CPP="./throw-empty-cpp $ITERATIONS $STACK_HEIGHT" + JAVA="java ThrowEmpty $ITERATIONS $STACK_HEIGHT" + ;; +raise-finally) + CFAT="./throw-finally $ITERATIONS $STACK_HEIGHT" + CFAR="./resume-finally $ITERATIONS $STACK_HEIGHT" + CPP=unsupported + JAVA="java ThrowFinally $ITERATIONS $STACK_HEIGHT" + ;; +raise-other) + CFAT="./throw-other $ITERATIONS $STACK_HEIGHT" + CFAR="./resume-other $ITERATIONS $STACK_HEIGHT" + CPP="./throw-other-cpp $ITERATIONS $STACK_HEIGHT" + JAVA="java ThrowOther $ITERATIONS $STACK_HEIGHT" + ;; +*) + echo "No such test." >&2 + exit 2 + ;; +esac + +case "$1" in +cfa-t) echo $CFAT; $CFAT;; +cfa-r) echo $CFAR; $CFAR;; +cpp) echo $CPP; $CPP;; +java) echo $JAVA; $JAVA;; +esac Index: doc/theses/andrew_beach_MMath/code/throw-detor.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-detor.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-detor.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Throw Across Destructor +#include #include +#include #include @@ -25,11 +27,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -39,3 +42,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/throw-detor.cpp =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-detor.cpp (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-detor.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,5 +1,9 @@ // Throw Across Destructor +#include +#include #include -#include +#include + +using namespace std::chrono; struct EmptyException : public std::exception {}; @@ -21,11 +25,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], nullptr, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], nullptr, 10); } + time_point start_time = steady_clock::now(); for (int count = 0 ; count < times ; ++count) { try { @@ -35,3 +40,6 @@ } } + time_point end_time = steady_clock::now(); + nanoseconds duration = duration_cast(end_time - start_time); + std::cout << "Run-Time (ns): " << duration.count() << std::endl; } Index: doc/theses/andrew_beach_MMath/code/throw-empty.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-empty.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-empty.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Throw Across Empty Function +#include #include +#include #include @@ -18,11 +20,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (unsigned int count = 0 ; count < times ; ++count) { try { @@ -32,3 +35,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/throw-empty.cpp =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-empty.cpp (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-empty.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,5 +1,9 @@ // Throw Across Empty Function +#include +#include #include -#include +#include + +using namespace std::chrono; struct EmptyException : public std::exception {}; @@ -16,11 +20,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], nullptr, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], nullptr, 10); } + time_point start_time = steady_clock::now(); for (unsigned int count = 0 ; count < times ; ++count) { try { @@ -30,3 +35,6 @@ } } + time_point end_time = steady_clock::now(); + nanoseconds duration = duration_cast(end_time - start_time); + std::cout << "Run-Time (ns): " << duration.count() << std::endl; } Index: doc/theses/andrew_beach_MMath/code/throw-finally.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-finally.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-finally.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Throw Across Finally +#include #include +#include #include @@ -22,11 +24,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -36,3 +39,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/throw-other.cfa =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-other.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-other.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,4 +1,6 @@ // Throw Across Other Handler +#include #include +#include #include @@ -24,11 +26,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], 0p, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], 0p, 10); } + Time start_time = timeHiRes(); for (int count = 0 ; count < times ; ++count) { try { @@ -38,3 +41,5 @@ } } + Time end_time = timeHiRes(); + sout | "Run-Time (ns): " | (end_time - start_time)`ns; } Index: doc/theses/andrew_beach_MMath/code/throw-other.cpp =================================================================== --- doc/theses/andrew_beach_MMath/code/throw-other.cpp (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/andrew_beach_MMath/code/throw-other.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1,5 +1,9 @@ // Throw Across Other Handler +#include +#include #include -#include +#include + +using namespace std::chrono; struct EmptyException : public std::exception {}; @@ -22,11 +26,12 @@ unsigned int times = 1; unsigned int total_frames = 1; - if (2 < argc) { + if (1 < argc) { times = strtol(argv[1], nullptr, 10); } - if (3 < argc) { + if (2 < argc) { total_frames = strtol(argv[2], nullptr, 10); } + time_point start_time = steady_clock::now(); for (int count = 0 ; count < times ; ++count) { try { @@ -36,3 +41,6 @@ } } + time_point end_time = steady_clock::now(); + nanoseconds duration = duration_cast(end_time - start_time); + std::cout << "Run-Time (ns): " << duration.count() << std::endl; } Index: doc/theses/mubeen_zulfiqar_MMath/allocator.tex =================================================================== --- doc/theses/mubeen_zulfiqar_MMath/allocator.tex (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ doc/theses/mubeen_zulfiqar_MMath/allocator.tex (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -44,18 +44,68 @@ \subsection{Design philosophy} - +The objective of uHeapLmmm's new design was to fulfill following requirements: +\begin{itemize} +\item It should be concurrent to be used in multi-threaded programs. +\item It should avoid global locks, on resources shared across all threads, as much as possible. +\item It's performance (FIX ME: cite performance benchmarks) should be comparable to the commonly used allocators (FIX ME: cite common allocators). +\item It should be a lightweight memory allocator. +\end{itemize} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Background and previous design of uHeapLmmm} - +uHeapLmmm was originally designed by X in X (FIX ME: add original author after confirming with Peter). +(FIX ME: make and add figure of previous design with description) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Distributed design of uHeapLmmm} +uHeapLmmm's design was reviewed and changed to fulfill new requirements (FIX ME: cite allocator philosophy). For this purpose, following two designs of uHeapLmm were proposed: +\paragraph{Design 1: Decentralized} +Fixed number of heaps: shard the heap into N heaps each with a bump-area allocated from the @sbrk@ area. +Kernel threads (KT) are assigned to the N heaps. +When KTs $\le$ N, the heaps are uncontented. +When KTs $>$ N, the heaps are contented. +By adjusting N, this approach reduces storage at the cost of speed due to contention. +In all cases, a thread acquires/releases a lock, contented or uncontented. +\begin{cquote} +\centering +\input{AllocDS1} +\end{cquote} +Problems: need to know when a KT is created and destroyed to know when to assign/un-assign a heap to the KT. + +\paragraph{Design 2: Centralized} +One heap, but lower bucket sizes are N-shared across KTs. +This design leverages the fact that 95\% of allocation requests are less than 512 bytes and there are only 3--5 different request sizes. +When KTs $\le$ N, the important bucket sizes are uncontented. +When KTs $>$ N, the free buckets are contented. +Therefore, threads are only contending for a small number of buckets, which are distributed among them to reduce contention. +\begin{cquote} +\centering +\input{AllocDS2} +\end{cquote} +Problems: need to know when a kernel thread (KT) is created and destroyed to know when to assign a shared bucket-number. +When no thread is assigned a bucket number, its free storage is unavailable. All KTs will be contended for one lock on sbrk for their initial allocations (before free-lists gets populated). + +Out of the two designs, Design 1 was chosen because it's concurrency is better across all bucket-sizes as design-2 shards a few buckets of selected sizes while design-1 shards all the buckets. Design-2 shards the whole heap which has all the buckets with the addition of sharding sbrk area. \subsection{Advantages of distributed design} +The distributed design of uHeapLmmm is concurrent to work in multi-threaded applications. +Some key benefits of the distributed design of uHeapLmmm are as follows: + +\begin{itemize} +\item +The bump allocation is concurrent as memory taken from sbrk is sharded across all heaps as bump allocation reserve. The lock on bump allocation (on memory taken from sbrk) will only be contended if KTs > N. The contention on sbrk area is less likely as it will only happen in the case if heaps assigned to two KTs get short of bump allocation reserve simultanously. +\item +N heaps are created at the start of the program and destroyed at the end of program. When a KT is created, we only assign it to one of the heaps. When a KT is destroyed, we only dissociate it from the assigned heap but we do not destroy that heap. That heap will go back to our pool-of-heaps, ready to be used by some new KT. And if that heap was shared among multiple KTs (like the case of KTs > N) then, on deletion of one KT, that heap will be still in-use of the other KTs. This will prevent creation and deletion of heaps during run-time as heaps are re-usable which helps in keeping low-memory footprint. +\item +It is possible to use sharing and stealing techniques to share/find unused storage, when a free list is unused or empty. +\item +Distributed design avoids unnecassry locks on resources shared across all KTs. +\end{itemize} + +FIX ME: Cite performance comparison of the two heap designs if required %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -72,39 +122,2 @@ Why did we need it? The added benefits. - - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -% Following is added by Peter - -\noindent -==================== - -\newpage -\paragraph{Design 1: Decentralized} -Fixed number of heaps: shard the heap into N heaps each with a bump-area allocated from the @sbrk@ area. -Kernel threads (KT) are assigned to the N heaps. -When KTs $\le$ N, the heaps are uncontented. -When KTs $>$ N, the heaps are contented. -By adjusting N, this approach reduces storage at the cost of speed due to contention. -In all cases, a thread acquires/releases a lock, contented or uncontented. -\begin{cquote} -\centering -\input{AllocDS1} -\end{cquote} -Problems: need to know when a KT is created and destroyed to know when to create/delete the KT's heap. -On KT deletion, its heap freed-storage needs to be distributed somewhere. - -\paragraph{Design 2: Centralized} - -One heap, but lower bucket sizes are N-shared across KTs. -This design leverages the fact that 95\% of allocation requests are less than 512 bytes and there are only 3--5 different request sizes. -When KTs $\le$ N, the important bucket sizes are uncontented. -When KTs $>$ N, the free buckets are contented. -Therefore, threads are only contending for a small number of buckets, which are distributed among them to reduce contention. -\begin{cquote} -\centering -\input{AllocDS2} -\end{cquote} -Problems: need to know when a kernel thread (KT) is created and destroyed to know when to assign a shared bucket-number. -When no thread is assigned a bucket number, its free storage is unavailable. -It is possible to use sharing and stealing techniques to share/find unused storage, when a free list is unused or empty. Index: libcfa/prelude/builtins.c =================================================================== --- libcfa/prelude/builtins.c (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/prelude/builtins.c (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -57,14 +57,14 @@ // generator support -struct $generator { +struct generator$ { inline int; }; -static inline void ?{}($generator & this) { ((int&)this) = 0; } -static inline void ^?{}($generator &) {} +static inline void ?{}(generator$ & this) { ((int&)this) = 0; } +static inline void ^?{}(generator$ &) {} trait is_generator(T &) { void main(T & this); - $generator * get_generator(T & this); + generator$ * get_generator(T & this); }; Index: libcfa/src/bits/weakso_locks.cfa =================================================================== --- libcfa/src/bits/weakso_locks.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/bits/weakso_locks.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -24,5 +24,5 @@ bool try_lock( blocking_lock & ) { return false; } void unlock( blocking_lock & ) {} -void on_notify( blocking_lock &, struct $thread * ) {} +void on_notify( blocking_lock &, struct thread$ * ) {} size_t on_wait( blocking_lock & ) { return 0; } void on_wakeup( blocking_lock &, size_t ) {} Index: libcfa/src/bits/weakso_locks.hfa =================================================================== --- libcfa/src/bits/weakso_locks.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/bits/weakso_locks.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -23,5 +23,5 @@ #include "containers/list.hfa" -struct $thread; +struct thread$; //----------------------------------------------------------------------------- @@ -32,5 +32,5 @@ // List of blocked threads - dlist( $thread ) blocked_threads; + dlist( thread$ ) blocked_threads; // Count of current blocked threads @@ -44,5 +44,5 @@ // Current thread owning the lock - struct $thread * owner; + struct thread$ * owner; // Number of recursion level @@ -56,5 +56,5 @@ bool try_lock( blocking_lock & this ) OPTIONAL_THREAD; void unlock( blocking_lock & this ) OPTIONAL_THREAD; -void on_notify( blocking_lock & this, struct $thread * t ) OPTIONAL_THREAD; +void on_notify( blocking_lock & this, struct thread$ * t ) OPTIONAL_THREAD; size_t on_wait( blocking_lock & this ) OPTIONAL_THREAD; void on_wakeup( blocking_lock & this, size_t ) OPTIONAL_THREAD; @@ -74,3 +74,3 @@ static inline size_t on_wait ( multiple_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); } static inline void on_wakeup( multiple_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); } -static inline void on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); } +static inline void on_notify( multiple_acquisition_lock & this, struct thread$ * t ){ on_notify( (blocking_lock &)this, t ); } Index: libcfa/src/concurrency/alarm.cfa =================================================================== --- libcfa/src/concurrency/alarm.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/alarm.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -51,5 +51,5 @@ //============================================================================================= -void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period) with( this ) { +void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period) with( this ) { this.initial = alarm; this.period = period; Index: libcfa/src/concurrency/alarm.hfa =================================================================== --- libcfa/src/concurrency/alarm.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/alarm.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -25,5 +25,5 @@ #include "containers/list.hfa" -struct $thread; +struct thread$; struct processor; @@ -52,5 +52,5 @@ union { - $thread * thrd; // thrd who created event + thread$ * thrd; // thrd who created event processor * proc; // proc who created event Alarm_Callback callback; // callback to handle event @@ -63,5 +63,5 @@ P9_EMBEDDED( alarm_node_t, dlink(alarm_node_t) ) -void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period ); +void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period ); void ?{}( alarm_node_t & this, processor * proc, Duration alarm, Duration period ); void ?{}( alarm_node_t & this, Alarm_Callback callback, Duration alarm, Duration period ); Index: libcfa/src/concurrency/clib/cfathread.cfa =================================================================== --- libcfa/src/concurrency/clib/cfathread.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/clib/cfathread.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -23,5 +23,5 @@ #include "cfathread.h" -extern void ?{}(processor &, const char[], cluster &, $thread *); +extern void ?{}(processor &, const char[], cluster &, thread$ *); extern "C" { extern void __cfactx_invoke_thread(void (*main)(void *), void * this); @@ -34,5 +34,5 @@ struct cfathread_object { - $thread self; + thread$ self; void * (*themain)( void * ); void * arg; @@ -42,5 +42,5 @@ void ^?{}(cfathread_object & mutex this); -static inline $thread * get_thread( cfathread_object & this ) { return &this.self; } +static inline thread$ * get_thread( cfathread_object & this ) { return &this.self; } typedef ThreadCancelled(cfathread_object) cfathread_exception; @@ -81,5 +81,5 @@ // Special Init Thread responsible for the initialization or processors struct __cfainit { - $thread self; + thread$ self; void (*init)( void * ); void * arg; @@ -88,5 +88,5 @@ void ^?{}(__cfainit & mutex this); -static inline $thread * get_thread( __cfainit & this ) { return &this.self; } +static inline thread$ * get_thread( __cfainit & this ) { return &this.self; } typedef ThreadCancelled(__cfainit) __cfainit_exception; @@ -109,5 +109,5 @@ // Don't use __thrd_start! just prep the context manually - $thread * this_thrd = get_thread(this); + thread$ * this_thrd = get_thread(this); void (*main_p)(__cfainit &) = main; Index: libcfa/src/concurrency/coroutine.cfa =================================================================== --- libcfa/src/concurrency/coroutine.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/coroutine.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -37,5 +37,5 @@ extern "C" { - void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__)); + void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__)); static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__)); static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) { @@ -62,5 +62,5 @@ forall(T & | is_coroutine(T)) void __cfaehm_cancelled_coroutine( - T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) { + T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) { verify( desc->cancellation ); desc->state = Cancelled; @@ -114,5 +114,5 @@ } -void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) { +void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) with( this ) { (this.context){0p, 0p}; (this.stack){storage, storageSize}; @@ -124,8 +124,8 @@ } -void ^?{}($coroutine& this) { +void ^?{}(coroutine$& this) { if(this.state != Halted && this.state != Start && this.state != Primed) { - $coroutine * src = active_coroutine(); - $coroutine * dst = &this; + coroutine$ * src = active_coroutine(); + coroutine$ * dst = &this; struct _Unwind_Exception storage; @@ -148,5 +148,5 @@ forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); }) void prime(T& cor) { - $coroutine* this = get_coroutine(cor); + coroutine$* this = get_coroutine(cor); assert(this->state == Start); @@ -248,6 +248,6 @@ // is not inline (We can't inline Cforall in C) extern "C" { - void __cfactx_cor_leave( struct $coroutine * src ) { - $coroutine * starter = src->cancellation != 0 ? src->last : src->starter; + void __cfactx_cor_leave( struct coroutine$ * src ) { + coroutine$ * starter = src->cancellation != 0 ? src->last : src->starter; src->state = Halted; @@ -265,9 +265,9 @@ } - struct $coroutine * __cfactx_cor_finish(void) { - struct $coroutine * cor = active_coroutine(); + struct coroutine$ * __cfactx_cor_finish(void) { + struct coroutine$ * cor = active_coroutine(); // get the active thread once - $thread * athrd = active_thread(); + thread$ * athrd = active_thread(); /* paranoid */ verify( athrd->corctx_flag ); Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/coroutine.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -39,8 +39,8 @@ trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) { void main(T & this); - $coroutine * get_coroutine(T & this); + coroutine$ * get_coroutine(T & this); }; -#define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this) +#define DECL_COROUTINE(X) static inline coroutine$* get_coroutine(X& this) { return &this.__cor; } void main(X& this) //----------------------------------------------------------------------------- @@ -49,12 +49,12 @@ // void ^?{}( coStack_t & this ); -void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ); -void ^?{}( $coroutine & this ); - -static inline void ?{}( $coroutine & this) { this{ "Anonymous Coroutine", 0p, 0 }; } -static inline void ?{}( $coroutine & this, size_t stackSize) { this{ "Anonymous Coroutine", 0p, stackSize }; } -static inline void ?{}( $coroutine & this, void * storage, size_t storageSize ) { this{ "Anonymous Coroutine", storage, storageSize }; } -static inline void ?{}( $coroutine & this, const char name[]) { this{ name, 0p, 0 }; } -static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; } +void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ); +void ^?{}( coroutine$ & this ); + +static inline void ?{}( coroutine$ & this) { this{ "Anonymous Coroutine", 0p, 0 }; } +static inline void ?{}( coroutine$ & this, size_t stackSize) { this{ "Anonymous Coroutine", 0p, stackSize }; } +static inline void ?{}( coroutine$ & this, void * storage, size_t storageSize ) { this{ "Anonymous Coroutine", storage, storageSize }; } +static inline void ?{}( coroutine$ & this, const char name[]) { this{ name, 0p, 0 }; } +static inline void ?{}( coroutine$ & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; } //----------------------------------------------------------------------------- @@ -63,5 +63,5 @@ void prime(T & cor); -static inline struct $coroutine * active_coroutine() { return active_thread()->curr_cor; } +static inline struct coroutine$ * active_coroutine() { return active_thread()->curr_cor; } //----------------------------------------------------------------------------- @@ -73,7 +73,7 @@ forall(T &) - void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *)); - - extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__)); + void __cfactx_start(void (*main)(T &), struct coroutine$ * cor, T & this, void (*invoke)(void (*main)(void *), void *)); + + extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__)); extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch"); @@ -82,10 +82,10 @@ // Private wrappers for context switch and stack creation // Wrapper for co -static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) { +static inline void $ctx_switch( coroutine$ * src, coroutine$ * dst ) __attribute__((nonnull (1, 2))) { // set state of current coroutine to inactive src->state = src->state == Halted ? Halted : Blocked; // get the active thread once - $thread * athrd = active_thread(); + thread$ * athrd = active_thread(); // Mark the coroutine @@ -124,5 +124,5 @@ // will also migrate which means this value will // stay in syn with the TLS - $coroutine * src = active_coroutine(); + coroutine$ * src = active_coroutine(); assertf( src->last != 0, @@ -141,5 +141,5 @@ forall(T & | is_coroutine(T)) void __cfaehm_cancelled_coroutine( - T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ); + T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ); // Resume implementation inlined for performance @@ -151,6 +151,6 @@ // will also migrate which means this value will // stay in syn with the TLS - $coroutine * src = active_coroutine(); - $coroutine * dst = get_coroutine(cor); + coroutine$ * src = active_coroutine(); + coroutine$ * dst = get_coroutine(cor); if( unlikely(dst->context.SP == 0p) ) { @@ -180,5 +180,5 @@ } -static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) { +static inline void resume( coroutine$ * dst ) __attribute__((nonnull (1))) { // optimization : read TLS once and reuse it // Safety note: this is preemption safe since if @@ -186,5 +186,5 @@ // will also migrate which means this value will // stay in syn with the TLS - $coroutine * src = active_coroutine(); + coroutine$ * src = active_coroutine(); // not resuming self ? Index: libcfa/src/concurrency/exception.cfa =================================================================== --- libcfa/src/concurrency/exception.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/exception.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -20,5 +20,5 @@ #include "coroutine.hfa" -extern struct $thread * mainThread; +extern struct thread$ * mainThread; extern "C" { extern void __cfactx_thrd_leave(); @@ -55,6 +55,6 @@ STOP_AT_END_FUNCTION(coroutine_cancelstop, - struct $coroutine * src = ($coroutine *)stop_param; - struct $coroutine * dst = src->last; + struct coroutine$ * src = (coroutine$ *)stop_param; + struct coroutine$ * dst = src->last; $ctx_switch( src, dst ); @@ -72,7 +72,7 @@ void * stop_param; - struct $thread * this_thread = active_thread(); + struct thread$ * this_thread = active_thread(); if ( &this_thread->self_cor != this_thread->curr_cor ) { - struct $coroutine * cor = this_thread->curr_cor; + struct coroutine$ * cor = this_thread->curr_cor; cor->cancellation = unwind_exception; Index: libcfa/src/concurrency/future.hfa =================================================================== --- libcfa/src/concurrency/future.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/future.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -37,5 +37,5 @@ // Fulfil the future, returns whether or not someone was unblocked - $thread * fulfil( future(T) & this, T result ) { + thread$ * fulfil( future(T) & this, T result ) { this.result = result; return fulfil( (future_t&)this ); Index: libcfa/src/concurrency/invoke.c =================================================================== --- libcfa/src/concurrency/invoke.c (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/invoke.c (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -29,6 +29,6 @@ // Called from the kernel when starting a coroutine or task so must switch back to user mode. -extern struct $coroutine * __cfactx_cor_finish(void); -extern void __cfactx_cor_leave ( struct $coroutine * ); +extern struct coroutine$ * __cfactx_cor_finish(void); +extern void __cfactx_cor_leave ( struct coroutine$ * ); extern void __cfactx_thrd_leave(); @@ -41,5 +41,5 @@ ) { // Finish setting up the coroutine by setting its state - struct $coroutine * cor = __cfactx_cor_finish(); + struct coroutine$ * cor = __cfactx_cor_finish(); // Call the main of the coroutine @@ -70,6 +70,6 @@ } -void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__)); -void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) { +void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) __attribute__ ((__noreturn__)); +void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) { _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor ); printf("UNWIND ERROR %d after force unwind\n", ret); @@ -100,5 +100,5 @@ void __cfactx_start( void (*main)(void *), - struct $coroutine * cor, + struct coroutine$ * cor, void *this, void (*invoke)(void *) Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/invoke.h (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -71,5 +71,5 @@ enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting }; - struct $coroutine { + struct coroutine$ { // context that is switch during a __cfactx_switch struct __stack_context_t context; @@ -85,8 +85,8 @@ // first coroutine to resume this one - struct $coroutine * starter; + struct coroutine$ * starter; // last coroutine to resume this one - struct $coroutine * last; + struct coroutine$ * last; // If non-null stack must be unwound with this exception @@ -95,7 +95,7 @@ }; // Wrapper for gdb - struct cfathread_coroutine_t { struct $coroutine debug; }; - - static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { + struct cfathread_coroutine_t { struct coroutine$ debug; }; + + static inline struct __stack_t * __get_stack( struct coroutine$ * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); } @@ -110,13 +110,13 @@ }; - struct $monitor { + struct monitor$ { // spinlock to protect internal data struct __spinlock_t lock; // current owner of the monitor - struct $thread * owner; + struct thread$ * owner; // queue of threads that are blocked waiting for the monitor - __queue_t(struct $thread) entry_queue; + __queue_t(struct thread$) entry_queue; // stack of conditions to run next once we exit the monitor @@ -133,9 +133,9 @@ }; // Wrapper for gdb - struct cfathread_monitor_t { struct $monitor debug; }; + struct cfathread_monitor_t { struct monitor$ debug; }; struct __monitor_group_t { // currently held monitors - __cfa_anonymous_object( __small_array_t($monitor*) ); + __cfa_anonymous_object( __small_array_t(monitor$*) ); // last function that acquired monitors @@ -146,9 +146,9 @@ // instrusive link field for threads struct __thread_desc_link { - struct $thread * next; + struct thread$ * next; volatile unsigned long long ts; }; - struct $thread { + struct thread$ { // Core threading fields // context that is switch during a __cfactx_switch @@ -179,14 +179,14 @@ // coroutine body used to store context - struct $coroutine self_cor; + struct coroutine$ self_cor; // current active context - struct $coroutine * curr_cor; + struct coroutine$ * curr_cor; // monitor body used for mutual exclusion - struct $monitor self_mon; + struct monitor$ self_mon; // pointer to monitor with sufficient lifetime for current monitors - struct $monitor * self_mon_p; + struct monitor$ * self_mon_p; // monitors currently held by this thread @@ -195,14 +195,14 @@ // used to put threads on user data structures struct { - struct $thread * next; - struct $thread * back; + struct thread$ * next; + struct thread$ * back; } seqable; // used to put threads on dlist data structure - __cfa_dlink($thread); + __cfa_dlink(thread$); struct { - struct $thread * next; - struct $thread * prev; + struct thread$ * next; + struct thread$ * prev; } node; @@ -214,11 +214,11 @@ }; #ifdef __cforall - P9_EMBEDDED( $thread, dlink($thread) ) + P9_EMBEDDED( thread$, dlink(thread$) ) #endif // Wrapper for gdb - struct cfathread_thread_t { struct $thread debug; }; + struct cfathread_thread_t { struct thread$ debug; }; #ifdef __CFA_DEBUG__ - void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]); + void __cfaabi_dbg_record_thrd(thread$ & this, bool park, const char prev_name[]); #else #define __cfaabi_dbg_record_thrd(x, y, z) @@ -228,25 +228,25 @@ extern "Cforall" { - static inline $thread *& get_next( $thread & this ) __attribute__((const)) { + static inline thread$ *& get_next( thread$ & this ) __attribute__((const)) { return this.link.next; } - static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) { + static inline [thread$ *&, thread$ *& ] __get( thread$ & this ) __attribute__((const)) { return this.node.[next, prev]; } - static inline $thread * volatile & ?`next ( $thread * this ) __attribute__((const)) { + static inline thread$ * volatile & ?`next ( thread$ * this ) __attribute__((const)) { return this->seqable.next; } - static inline $thread *& Back( $thread * this ) __attribute__((const)) { + static inline thread$ *& Back( thread$ * this ) __attribute__((const)) { return this->seqable.back; } - static inline $thread *& Next( $thread * this ) __attribute__((const)) { + static inline thread$ *& Next( thread$ * this ) __attribute__((const)) { return this->seqable.next; } - static inline bool listed( $thread * this ) { + static inline bool listed( thread$ * this ) { return this->seqable.next != 0p; } @@ -258,5 +258,5 @@ } - static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) { + static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func) { (this.data){data}; (this.size){size}; Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/io.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -90,5 +90,5 @@ static inline unsigned __flush( struct $io_context & ); static inline __u32 __release_sqes( struct $io_context & ); - extern void __kernel_unpark( $thread * thrd ); + extern void __kernel_unpark( thread$ * thrd ); bool __cfa_io_drain( processor * proc ) { Index: libcfa/src/concurrency/io/types.hfa =================================================================== --- libcfa/src/concurrency/io/types.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/io/types.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -179,5 +179,5 @@ static inline { - $thread * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) { + thread$ * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) { this.result = result; return fulfil(this.self, do_unpark); Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/kernel.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -110,13 +110,13 @@ #endif -extern $thread * mainThread; +extern thread$ * mainThread; extern processor * mainProcessor; //----------------------------------------------------------------------------- // Kernel Scheduling logic -static $thread * __next_thread(cluster * this); -static $thread * __next_thread_slow(cluster * this); -static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1))); -static void __run_thread(processor * this, $thread * dst); +static thread$ * __next_thread(cluster * this); +static thread$ * __next_thread_slow(cluster * this); +static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1))); +static void __run_thread(processor * this, thread$ * dst); static void __wake_one(cluster * cltr); @@ -181,5 +181,5 @@ __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this); - $thread * readyThread = 0p; + thread$ * readyThread = 0p; MAIN_LOOP: for() { @@ -388,5 +388,5 @@ // runThread runs a thread by context switching // from the processor coroutine to the target thread -static void __run_thread(processor * this, $thread * thrd_dst) { +static void __run_thread(processor * this, thread$ * thrd_dst) { /* paranoid */ verify( ! __preemption_enabled() ); /* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted); @@ -396,5 +396,5 @@ __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name); - $coroutine * proc_cor = get_coroutine(this->runner); + coroutine$ * proc_cor = get_coroutine(this->runner); // set state of processor coroutine to inactive @@ -415,6 +415,6 @@ /* paranoid */ verify( thrd_dst->context.SP ); /* paranoid */ verify( thrd_dst->state != Halted ); - /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor - /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor + /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor + /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary ); @@ -428,6 +428,6 @@ /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary ); - /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); - /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); + /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); + /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); /* paranoid */ verify( thrd_dst->context.SP ); /* paranoid */ verify( thrd_dst->curr_cluster == this->cltr ); @@ -497,6 +497,6 @@ void returnToKernel() { /* paranoid */ verify( ! __preemption_enabled() ); - $coroutine * proc_cor = get_coroutine(kernelTLS().this_processor->runner); - $thread * thrd_src = kernelTLS().this_thread; + coroutine$ * proc_cor = get_coroutine(kernelTLS().this_processor->runner); + thread$ * thrd_src = kernelTLS().this_thread; __STATS( thrd_src->last_proc = kernelTLS().this_processor; ) @@ -526,6 +526,6 @@ /* paranoid */ verify( ! __preemption_enabled() ); - /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src ); - /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src ); + /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_src ); + /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_src ); } @@ -533,5 +533,5 @@ // Scheduler routines // KERNEL ONLY -static void __schedule_thread( $thread * thrd ) { +static void __schedule_thread( thread$ * thrd ) { /* paranoid */ verify( ! __preemption_enabled() ); /* paranoid */ verify( ready_schedule_islocked()); @@ -583,5 +583,5 @@ } -void schedule_thread$( $thread * thrd ) { +void schedule_thread$( thread$ * thrd ) { ready_schedule_lock(); __schedule_thread( thrd ); @@ -590,9 +590,9 @@ // KERNEL ONLY -static inline $thread * __next_thread(cluster * this) with( *this ) { +static inline thread$ * __next_thread(cluster * this) with( *this ) { /* paranoid */ verify( ! __preemption_enabled() ); ready_schedule_lock(); - $thread * thrd = pop_fast( this ); + thread$ * thrd = pop_fast( this ); ready_schedule_unlock(); @@ -602,9 +602,9 @@ // KERNEL ONLY -static inline $thread * __next_thread_slow(cluster * this) with( *this ) { +static inline thread$ * __next_thread_slow(cluster * this) with( *this ) { /* paranoid */ verify( ! __preemption_enabled() ); ready_schedule_lock(); - $thread * thrd; + thread$ * thrd; for(25) { thrd = pop_slow( this ); @@ -620,5 +620,5 @@ } -static inline bool __must_unpark( $thread * thrd ) { +static inline bool __must_unpark( thread$ * thrd ) { int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST); switch(old_ticket) { @@ -636,5 +636,5 @@ } -void __kernel_unpark( $thread * thrd ) { +void __kernel_unpark( thread$ * thrd ) { /* paranoid */ verify( ! __preemption_enabled() ); /* paranoid */ verify( ready_schedule_islocked()); @@ -651,5 +651,5 @@ } -void unpark( $thread * thrd ) { +void unpark( thread$ * thrd ) { if( !thrd ) return; @@ -675,6 +675,6 @@ // Should never return void __cfactx_thrd_leave() { - $thread * thrd = active_thread(); - $monitor * this = &thrd->self_mon; + thread$ * thrd = active_thread(); + monitor$ * this = &thrd->self_mon; // Lock the monitor now @@ -688,6 +688,6 @@ /* paranoid */ verify( kernelTLS().this_thread == thrd ); /* paranoid */ verify( thrd->context.SP ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd ); thrd->state = Halting; @@ -707,5 +707,5 @@ bool force_yield( __Preemption_Reason reason ) { __disable_interrupts_checked(); - $thread * thrd = kernelTLS().this_thread; + thread$ * thrd = kernelTLS().this_thread; /* paranoid */ verify(thrd->state == Active); @@ -819,5 +819,5 @@ //============================================================================================= void __kernel_abort_msg( char * abort_text, int abort_text_size ) { - $thread * thrd = __cfaabi_tls.this_thread; + thread$ * thrd = __cfaabi_tls.this_thread; if(thrd) { Index: libcfa/src/concurrency/kernel.hfa =================================================================== --- libcfa/src/concurrency/kernel.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/kernel.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -115,5 +115,5 @@ // it is not a particularly safe scheme as it can make processors less homogeneous struct { - $thread * thrd; + thread$ * thrd; } init; @@ -215,5 +215,5 @@ // List of threads __spinlock_t thread_list_lock; - __dllist_t(struct $thread) threads; + __dllist_t(struct thread$) threads; unsigned int nthreads; Index: libcfa/src/concurrency/kernel/fwd.hfa =================================================================== --- libcfa/src/concurrency/kernel/fwd.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/kernel/fwd.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -24,5 +24,5 @@ #endif -struct $thread; +struct thread$; struct processor; struct cluster; @@ -36,5 +36,5 @@ extern "Cforall" { extern __attribute__((aligned(128))) thread_local struct KernelThreadData { - struct $thread * volatile this_thread; + struct thread$ * volatile this_thread; struct processor * volatile this_processor; volatile bool sched_lock; @@ -120,7 +120,7 @@ extern "Cforall" { extern void park( void ); - extern void unpark( struct $thread * this ); - static inline struct $thread * active_thread () { - struct $thread * t = publicTLS_get( this_thread ); + extern void unpark( struct thread$ * this ); + static inline struct thread$ * active_thread () { + struct thread$ * t = publicTLS_get( this_thread ); /* paranoid */ verify( t ); return t; @@ -144,5 +144,5 @@ // Semaphore which only supports a single thread struct single_sem { - struct $thread * volatile ptr; + struct thread$ * volatile ptr; }; @@ -156,5 +156,5 @@ bool wait(single_sem & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) { if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { @@ -175,5 +175,5 @@ bool post(single_sem & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) return false; if(expected == 0p) { @@ -200,5 +200,5 @@ // 1p : fulfilled (wait won't block) // any thread : a thread is currently waiting - struct $thread * volatile ptr; + struct thread$ * volatile ptr; }; @@ -214,5 +214,5 @@ bool wait(oneshot & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) return false; /* paranoid */ verify( expected == 0p ); @@ -227,6 +227,6 @@ // Mark as fulfilled, wake thread if needed // return true if a thread was unparked - $thread * post(oneshot & this, bool do_unpark = true) { - struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); + thread$ * post(oneshot & this, bool do_unpark = true) { + struct thread$ * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); if( got == 0p ) return 0p; if(do_unpark) unpark( got ); @@ -343,5 +343,5 @@ // from the server side, mark the future as fulfilled // delete it if needed - $thread * fulfil( future_t & this, bool do_unpark = true ) { + thread$ * fulfil( future_t & this, bool do_unpark = true ) { for() { struct oneshot * expected = this.ptr; @@ -364,5 +364,5 @@ if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; } - $thread * ret = post( *expected, do_unpark ); + thread$ * ret = post( *expected, do_unpark ); __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); return ret; Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -77,5 +77,5 @@ static void __kernel_first_resume( processor * this ); static void __kernel_last_resume ( processor * this ); -static void init(processor & this, const char name[], cluster & _cltr, $thread * initT); +static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT); static void deinit(processor & this); static void doregister( struct cluster & cltr ); @@ -83,6 +83,6 @@ static void register_tls( processor * this ); static void unregister_tls( processor * this ); -static void ?{}( $coroutine & this, current_stack_info_t * info); -static void ?{}( $thread & this, current_stack_info_t * info); +static void ?{}( coroutine$ & this, current_stack_info_t * info); +static void ?{}( thread$ & this, current_stack_info_t * info); static void ?{}(processorCtx_t & this) {} static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info); @@ -105,5 +105,5 @@ KERNEL_STORAGE(cluster, mainCluster); KERNEL_STORAGE(processor, mainProcessor); -KERNEL_STORAGE($thread, mainThread); +KERNEL_STORAGE(thread$, mainThread); KERNEL_STORAGE(__stack_t, mainThreadCtx); KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock); @@ -114,5 +114,5 @@ cluster * mainCluster; processor * mainProcessor; -$thread * mainThread; +thread$ * mainThread; __scheduler_RWLock_t * __scheduler_lock; @@ -203,5 +203,5 @@ // SKULLDUGGERY: the mainThread steals the process main thread // which will then be scheduled by the mainProcessor normally - mainThread = ($thread *)&storage_mainThread; + mainThread = (thread$ *)&storage_mainThread; current_stack_info_t info; info.storage = (__stack_t*)&storage_mainThreadCtx; @@ -397,6 +397,6 @@ static void __kernel_first_resume( processor * this ) { - $thread * src = mainThread; - $coroutine * dst = get_coroutine(this->runner); + thread$ * src = mainThread; + coroutine$ * dst = get_coroutine(this->runner); /* paranoid */ verify( ! __preemption_enabled() ); @@ -430,6 +430,6 @@ // KERNEL_ONLY static void __kernel_last_resume( processor * this ) { - $coroutine * src = &mainThread->self_cor; - $coroutine * dst = get_coroutine(this->runner); + coroutine$ * src = &mainThread->self_cor; + coroutine$ * dst = get_coroutine(this->runner); /* paranoid */ verify( ! __preemption_enabled() ); @@ -459,5 +459,5 @@ //----------------------------------------------------------------------------- // Main thread construction -static void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) { +static void ?{}( coroutine$ & this, current_stack_info_t * info) with( this ) { stack.storage = info->storage; with(*stack.storage) { @@ -474,5 +474,5 @@ } -static void ?{}( $thread & this, current_stack_info_t * info) with( this ) { +static void ?{}( thread$ & this, current_stack_info_t * info) with( this ) { ticket = TICKET_RUNNING; state = Start; @@ -506,5 +506,5 @@ } -static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) { +static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT) with( this ) { this.name = name; this.cltr = &_cltr; @@ -545,5 +545,5 @@ } -void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) { +void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) { ( this.terminated ){}; ( this.runner ){}; @@ -663,5 +663,5 @@ } -void doregister( cluster * cltr, $thread & thrd ) { +void doregister( cluster * cltr, thread$ & thrd ) { lock (cltr->thread_list_lock __cfaabi_dbg_ctx2); cltr->nthreads += 1; @@ -670,5 +670,5 @@ } -void unregister( cluster * cltr, $thread & thrd ) { +void unregister( cluster * cltr, thread$ & thrd ) { lock (cltr->thread_list_lock __cfaabi_dbg_ctx2); remove(cltr->threads, thrd ); Index: libcfa/src/concurrency/kernel_private.hfa =================================================================== --- libcfa/src/concurrency/kernel_private.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/kernel_private.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -46,10 +46,10 @@ } -void schedule_thread$( $thread * ) __attribute__((nonnull (1))); +void schedule_thread$( thread$ * ) __attribute__((nonnull (1))); extern bool __preemption_enabled(); //release/wake-up the following resources -void __thread_finish( $thread * thrd ); +void __thread_finish( thread$ * thrd ); //----------------------------------------------------------------------------- @@ -95,6 +95,6 @@ __cfaabi_dbg_debug_do( - extern void __cfaabi_dbg_thread_register ( $thread * thrd ); - extern void __cfaabi_dbg_thread_unregister( $thread * thrd ); + extern void __cfaabi_dbg_thread_register ( thread$ * thrd ); + extern void __cfaabi_dbg_thread_unregister( thread$ * thrd ); ) @@ -105,6 +105,6 @@ //----------------------------------------------------------------------------- // Utils -void doregister( struct cluster * cltr, struct $thread & thrd ); -void unregister( struct cluster * cltr, struct $thread & thrd ); +void doregister( struct cluster * cltr, struct thread$ & thrd ); +void unregister( struct cluster * cltr, struct thread$ & thrd ); //----------------------------------------------------------------------------- @@ -300,5 +300,5 @@ // push thread onto a ready queue for a cluster // returns true if the list was previously empty, false otherwise -__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool local); +__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool local); //----------------------------------------------------------------------- @@ -306,5 +306,5 @@ // returns 0p if empty // May return 0p spuriously -__attribute__((hot)) struct $thread * pop_fast(struct cluster * cltr); +__attribute__((hot)) struct thread$ * pop_fast(struct cluster * cltr); //----------------------------------------------------------------------- @@ -312,5 +312,5 @@ // returns 0p if empty // May return 0p spuriously -__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr); +__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr); //----------------------------------------------------------------------- @@ -318,5 +318,5 @@ // returns 0p if empty // guaranteed to find any threads added before this call -__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr); +__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr); //----------------------------------------------------------------------- Index: libcfa/src/concurrency/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/locks.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -32,5 +32,5 @@ // waiting thread - struct $thread * t; + struct thread$ * t; // shadow field @@ -45,5 +45,5 @@ P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) ) - void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) { + void ?{}( info_thread(L) & this, thread$ * t, uintptr_t info, L * l ) { this.t = t; this.info = info; @@ -71,5 +71,5 @@ void lock( blocking_lock & this ) with( this ) { lock( lock __cfaabi_dbg_ctx2 ); - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); // single acquisition lock is held by current thread @@ -117,5 +117,5 @@ void pop_and_set_new_owner( blocking_lock & this ) with( this ) { - $thread * t = &try_pop_front( blocked_threads ); + thread$ * t = &try_pop_front( blocked_threads ); owner = t; recursion_count = ( t ? 1 : 0 ); @@ -142,5 +142,5 @@ } -void on_notify( blocking_lock & this, $thread * t ) with( this ) { +void on_notify( blocking_lock & this, thread$ * t ) with( this ) { lock( lock __cfaabi_dbg_ctx2 ); // lock held @@ -366,6 +366,6 @@ } -$thread * V (semaphore & this, const bool doUnpark ) with( this ) { - $thread * thrd = 0p; +thread$ * V (semaphore & this, const bool doUnpark ) with( this ) { + thread$ * thrd = 0p; lock( lock __cfaabi_dbg_ctx2 ); count += 1; @@ -384,10 +384,10 @@ bool V(semaphore & this) with( this ) { - $thread * thrd = V(this, true); + thread$ * thrd = V(this, true); return thrd != 0p; } bool V(semaphore & this, unsigned diff) with( this ) { - $thread * thrd = 0p; + thread$ * thrd = 0p; lock( lock __cfaabi_dbg_ctx2 ); int release = max(-count, (int)diff); Index: libcfa/src/concurrency/locks.hfa =================================================================== --- libcfa/src/concurrency/locks.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/locks.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -39,8 +39,8 @@ struct Semaphore0nary { __spinlock_t lock; // needed to protect - mpsc_queue($thread) queue; -}; - -static inline bool P(Semaphore0nary & this, $thread * thrd) { + mpsc_queue(thread$) queue; +}; + +static inline bool P(Semaphore0nary & this, thread$ * thrd) { /* paranoid */ verify(!thrd`next); /* paranoid */ verify(!(&(*thrd)`next)); @@ -51,5 +51,5 @@ static inline bool P(Semaphore0nary & this) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); P(this, thrd); park(); @@ -57,6 +57,6 @@ } -static inline $thread * V(Semaphore0nary & this, bool doUnpark = true) { - $thread * next; +static inline thread$ * V(Semaphore0nary & this, bool doUnpark = true) { + thread$ * next; lock(this.lock __cfaabi_dbg_ctx2); for (;;) { @@ -124,5 +124,5 @@ static inline bool P(ThreadBenaphore & this, bool wait) { return wait ? P(this) : tryP(this); } -static inline $thread * V(ThreadBenaphore & this, bool doUnpark = true) { +static inline thread$ * V(ThreadBenaphore & this, bool doUnpark = true) { if (V(this.ben)) return 0p; return V(this.sem, doUnpark); @@ -134,5 +134,5 @@ __spinlock_t lock; int count; - __queue_t($thread) waiting; + __queue_t(thread$) waiting; }; @@ -142,5 +142,5 @@ bool V (semaphore & this); bool V (semaphore & this, unsigned count); -$thread * V (semaphore & this, bool ); +thread$ * V (semaphore & this, bool ); //---------- @@ -156,5 +156,5 @@ static inline size_t on_wait ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); } static inline void on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); } -static inline void on_notify( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); } +static inline void on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); } //---------- @@ -170,8 +170,8 @@ static inline size_t on_wait ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); } static inline void on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); } -static inline void on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); } +static inline void on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); } struct fast_lock { - $thread * volatile owner; + thread$ * volatile owner; ThreadBenaphore sem; }; @@ -179,6 +179,6 @@ static inline void ?{}(fast_lock & this) { this.owner = 0p; } -static inline bool $try_lock(fast_lock & this, $thread * thrd) { - $thread * exp = 0p; +static inline bool $try_lock(fast_lock & this, thread$ * thrd) { + thread$ * exp = 0p; return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); } @@ -186,5 +186,5 @@ static inline void lock( fast_lock & this ) __attribute__((artificial)); static inline void lock( fast_lock & this ) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); /* paranoid */verify(thrd != this.owner); @@ -197,11 +197,11 @@ static inline bool try_lock( fast_lock & this ) __attribute__((artificial)); static inline bool try_lock ( fast_lock & this ) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); /* paranoid */ verify(thrd != this.owner); return $try_lock(this, thrd); } -static inline $thread * unlock( fast_lock & this ) __attribute__((artificial)); -static inline $thread * unlock( fast_lock & this ) { +static inline thread$ * unlock( fast_lock & this ) __attribute__((artificial)); +static inline thread$ * unlock( fast_lock & this ) { /* paranoid */ verify(active_thread() == this.owner); @@ -216,5 +216,5 @@ static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; } static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); } -static inline void on_notify( fast_lock &, struct $thread * t ) { unpark(t); } +static inline void on_notify( fast_lock &, struct thread$ * t ) { unpark(t); } struct mcs_node { @@ -248,8 +248,8 @@ // Current thread owning the lock - struct $thread * owner; + struct thread$ * owner; // List of blocked threads - dlist( $thread ) blocked_threads; + dlist( thread$ ) blocked_threads; // Used for comparing and exchanging @@ -343,5 +343,5 @@ // block until signalled while (block(this)) if(try_lock_contention(this)) return true; - + // this should never be reached as block(this) always returns true return false; @@ -385,5 +385,5 @@ // block until signalled while (block(this)) if(try_lock_contention(this)) return true; - + // this should never be reached as block(this) always returns true return false; @@ -395,10 +395,10 @@ if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return; lock( spinlock __cfaabi_dbg_ctx2 ); - $thread * t = &try_pop_front( blocked_threads ); + thread$ * t = &try_pop_front( blocked_threads ); unlock( spinlock ); unpark( t ); } -static inline void on_notify(linear_backoff_then_block_lock & this, struct $thread * t ) { unpark(t); } +static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); } static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; } static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); } @@ -408,5 +408,5 @@ trait is_blocking_lock(L & | sized(L)) { // For synchronization locks to use when acquiring - void on_notify( L &, struct $thread * ); + void on_notify( L &, struct thread$ * ); // For synchronization locks to use when releasing @@ -442,5 +442,5 @@ int count; }; - + void ?{}( condition_variable(L) & this ); Index: libcfa/src/concurrency/monitor.cfa =================================================================== --- libcfa/src/concurrency/monitor.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/monitor.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// $monitor.c -- +// monitor.cfa -- // // Author : Thierry Delisle @@ -28,31 +28,31 @@ //----------------------------------------------------------------------------- // Forward declarations -static inline void __set_owner ( $monitor * this, $thread * owner ); -static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner ); -static inline void set_mask ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ); -static inline void reset_mask( $monitor * this ); - -static inline $thread * next_thread( $monitor * this ); -static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors ); +static inline void __set_owner ( monitor$ * this, thread$ * owner ); +static inline void __set_owner ( monitor$ * storage [], __lock_size_t count, thread$ * owner ); +static inline void set_mask ( monitor$ * storage [], __lock_size_t count, const __waitfor_mask_t & mask ); +static inline void reset_mask( monitor$ * this ); + +static inline thread$ * next_thread( monitor$ * this ); +static inline bool is_accepted( monitor$ * this, const __monitor_group_t & monitors ); static inline void lock_all ( __spinlock_t * locks [], __lock_size_t count ); -static inline void lock_all ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ); +static inline void lock_all ( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ); static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count ); -static inline void unlock_all( $monitor * locks [], __lock_size_t count ); - -static inline void save ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] ); -static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] ); - -static inline void init ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ); -static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ); - -static inline $thread * check_condition ( __condition_criterion_t * ); +static inline void unlock_all( monitor$ * locks [], __lock_size_t count ); + +static inline void save ( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] ); +static inline void restore( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] ); + +static inline void init ( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ); +static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ); + +static inline thread$ * check_condition ( __condition_criterion_t * ); static inline void brand_condition ( condition & ); -static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count ); +static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t &, monitor$ * monitors [], __lock_size_t count ); forall(T & | sized( T )) static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ); static inline __lock_size_t count_max ( const __waitfor_mask_t & mask ); -static inline __lock_size_t aggregate ( $monitor * storage [], const __waitfor_mask_t & mask ); +static inline __lock_size_t aggregate ( monitor$ * storage [], const __waitfor_mask_t & mask ); //----------------------------------------------------------------------------- @@ -69,5 +69,5 @@ #define monitor_ctx( mons, cnt ) /* Define that create the necessary struct for internal/external scheduling operations */ \ - $monitor ** monitors = mons; /* Save the targeted monitors */ \ + monitor$ ** monitors = mons; /* Save the targeted monitors */ \ __lock_size_t count = cnt; /* Save the count to a local variable */ \ unsigned int recursions[ count ]; /* Save the current recursion levels to restore them later */ \ @@ -82,6 +82,6 @@ // Enter/Leave routines // Enter single monitor -static void __enter( $monitor * this, const __monitor_group_t & group ) { - $thread * thrd = active_thread(); +static void __enter( monitor$ * this, const __monitor_group_t & group ) { + thread$ * thrd = active_thread(); // Lock the monitor spinlock @@ -141,6 +141,6 @@ } -static void __dtor_enter( $monitor * this, fptr_t func, bool join ) { - $thread * thrd = active_thread(); +static void __dtor_enter( monitor$ * this, fptr_t func, bool join ) { + thread$ * thrd = active_thread(); #if defined( __CFA_WITH_VERIFY__ ) bool is_thrd = this == &thrd->self_mon; @@ -173,5 +173,5 @@ // because join will not release the monitor after it executed. // to avoid that it sets the owner to the special value thrd | 1p before exiting - else if( this->owner == ($thread*)(1 | (uintptr_t)thrd) ) { + else if( this->owner == (thread$*)(1 | (uintptr_t)thrd) ) { // restore the owner and just return __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this); @@ -191,5 +191,5 @@ __lock_size_t count = 1; - $monitor ** monitors = &this; + monitor$ ** monitors = &this; __monitor_group_t group = { &this, 1, func }; if( is_accepted( this, group) ) { @@ -243,5 +243,5 @@ // Leave single monitor -void __leave( $monitor * this ) { +void __leave( monitor$ * this ) { // Lock the monitor spinlock lock( this->lock __cfaabi_dbg_ctx2 ); @@ -263,5 +263,5 @@ // Get the next thread, will be null on low contention monitor - $thread * new_owner = next_thread( this ); + thread$ * new_owner = next_thread( this ); // Check the new owner is consistent with who we wake-up @@ -278,5 +278,5 @@ // Leave single monitor for the last time -void __dtor_leave( $monitor * this, bool join ) { +void __dtor_leave( monitor$ * this, bool join ) { __cfaabi_dbg_debug_do( if( active_thread() != this->owner ) { @@ -288,9 +288,9 @@ ) - this->owner = ($thread*)(1 | (uintptr_t)this->owner); -} - -void __thread_finish( $thread * thrd ) { - $monitor * this = &thrd->self_mon; + this->owner = (thread$*)(1 | (uintptr_t)this->owner); +} + +void __thread_finish( thread$ * thrd ) { + monitor$ * this = &thrd->self_mon; // Lock the monitor now @@ -298,6 +298,6 @@ /* paranoid */ verify( this->lock.lock ); /* paranoid */ verify( thrd->context.SP ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd ); /* paranoid */ verify( ! __preemption_enabled() ); @@ -311,5 +311,5 @@ // Fetch the next thread, can be null - $thread * new_owner = next_thread( this ); + thread$ * new_owner = next_thread( this ); // Mark the state as fully halted @@ -336,5 +336,5 @@ // Leave multiple monitor // relies on the monitor array being sorted -static inline void leave($monitor * monitors [], __lock_size_t count) { +static inline void leave(monitor$ * monitors [], __lock_size_t count) { for( __lock_size_t i = count - 1; i >= 0; i--) { __leave( monitors[i] ); @@ -344,6 +344,6 @@ // Ctor for monitor guard // Sorts monitors before entering -void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) { - $thread * thrd = active_thread(); +void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) { + thread$ * thrd = active_thread(); // Store current array @@ -385,7 +385,7 @@ // Ctor for monitor guard // Sorts monitors before entering -void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func, bool join ) { +void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) { // optimization - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); // Store current array @@ -415,5 +415,5 @@ //----------------------------------------------------------------------------- // Internal scheduling types -void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) { +void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info ) { this.waiting_thread = waiting_thread; this.count = count; @@ -429,5 +429,5 @@ } -void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) { +void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t & owner ) { this.ready = false; this.target = target; @@ -463,5 +463,5 @@ // Find the next thread(s) to run __lock_size_t thread_count = 0; - $thread * threads[ count ]; + thread$ * threads[ count ]; __builtin_memset( threads, 0, sizeof( threads ) ); @@ -471,5 +471,5 @@ // Remove any duplicate threads for( __lock_size_t i = 0; i < count; i++) { - $thread * new_owner = next_thread( monitors[i] ); + thread$ * new_owner = next_thread( monitors[i] ); insert_unique( threads, thread_count, new_owner ); } @@ -501,5 +501,5 @@ //Some more checking in debug __cfaabi_dbg_debug_do( - $thread * this_thrd = active_thread(); + thread$ * this_thrd = active_thread(); if ( this.monitor_count != this_thrd->monitors.size ) { abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size ); @@ -555,5 +555,5 @@ //Find the thread to run - $thread * signallee = pop_head( this.blocked )->waiting_thread; + thread$ * signallee = pop_head( this.blocked )->waiting_thread; __set_owner( monitors, count, signallee ); @@ -608,5 +608,5 @@ // Create one! __lock_size_t max = count_max( mask ); - $monitor * mon_storage[max]; + monitor$ * mon_storage[max]; __builtin_memset( mon_storage, 0, sizeof( mon_storage ) ); __lock_size_t actual_count = aggregate( mon_storage, mask ); @@ -626,5 +626,5 @@ { // Check if the entry queue - $thread * next; int index; + thread$ * next; int index; [next, index] = search_entry_queue( mask, monitors, count ); @@ -636,5 +636,5 @@ verifyf( accepted.size == 1, "ERROR: Accepted dtor has more than 1 mutex parameter." ); - $monitor * mon2dtor = accepted[0]; + monitor$ * mon2dtor = accepted[0]; verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." ); @@ -730,5 +730,5 @@ // Utilities -static inline void __set_owner( $monitor * this, $thread * owner ) { +static inline void __set_owner( monitor$ * this, thread$ * owner ) { /* paranoid */ verify( this->lock.lock ); @@ -740,5 +740,5 @@ } -static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) { +static inline void __set_owner( monitor$ * monitors [], __lock_size_t count, thread$ * owner ) { /* paranoid */ verify ( monitors[0]->lock.lock ); /* paranoid */ verifyf( monitors[0]->owner == active_thread(), "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), monitors[0]->owner, monitors[0]->recursion, monitors[0] ); @@ -753,5 +753,5 @@ } -static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) { +static inline void set_mask( monitor$ * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) { for( __lock_size_t i = 0; i < count; i++) { storage[i]->mask = mask; @@ -759,5 +759,5 @@ } -static inline void reset_mask( $monitor * this ) { +static inline void reset_mask( monitor$ * this ) { this->mask.accepted = 0p; this->mask.data = 0p; @@ -765,5 +765,5 @@ } -static inline $thread * next_thread( $monitor * this ) { +static inline thread$ * next_thread( monitor$ * this ) { //Check the signaller stack __cfaabi_dbg_print_safe( "Kernel : mon %p AS-stack top %p\n", this, this->signal_stack.top); @@ -781,5 +781,5 @@ // No signaller thread // Get the next thread in the entry_queue - $thread * new_owner = pop_head( this->entry_queue ); + thread$ * new_owner = pop_head( this->entry_queue ); /* paranoid */ verifyf( !this->owner || active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this ); /* paranoid */ verify( !new_owner || new_owner->link.next == 0p ); @@ -789,5 +789,5 @@ } -static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) { +static inline bool is_accepted( monitor$ * this, const __monitor_group_t & group ) { __acceptable_t * it = this->mask.data; // Optim __lock_size_t count = this->mask.size; @@ -811,5 +811,5 @@ } -static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) { +static inline void init( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) { for( __lock_size_t i = 0; i < count; i++) { (criteria[i]){ monitors[i], waiter }; @@ -819,5 +819,5 @@ } -static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) { +static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) { for( __lock_size_t i = 0; i < count; i++) { (criteria[i]){ monitors[i], waiter }; @@ -835,5 +835,5 @@ } -static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) { +static inline void lock_all( monitor$ * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) { for( __lock_size_t i = 0; i < count; i++ ) { __spinlock_t * l = &source[i]->lock; @@ -849,5 +849,5 @@ } -static inline void unlock_all( $monitor * locks [], __lock_size_t count ) { +static inline void unlock_all( monitor$ * locks [], __lock_size_t count ) { for( __lock_size_t i = 0; i < count; i++ ) { unlock( locks[i]->lock ); @@ -856,5 +856,5 @@ static inline void save( - $monitor * ctx [], + monitor$ * ctx [], __lock_size_t count, __attribute((unused)) __spinlock_t * locks [], @@ -869,5 +869,5 @@ static inline void restore( - $monitor * ctx [], + monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], @@ -887,5 +887,5 @@ // 2 - Checks if all the monitors are ready to run // if so return the thread to run -static inline $thread * check_condition( __condition_criterion_t * target ) { +static inline thread$ * check_condition( __condition_criterion_t * target ) { __condition_node_t * node = target->owner; unsigned short count = node->count; @@ -910,5 +910,5 @@ static inline void brand_condition( condition & this ) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); if( !this.monitors ) { // __cfaabi_dbg_print_safe( "Branding\n" ); @@ -916,5 +916,5 @@ this.monitor_count = thrd->monitors.size; - this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) ); + this.monitors = (monitor$ **)malloc( this.monitor_count * sizeof( *this.monitors ) ); for( int i = 0; i < this.monitor_count; i++ ) { this.monitors[i] = thrd->monitors[i]; @@ -923,10 +923,10 @@ } -static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) { - - __queue_t($thread) & entry_queue = monitors[0]->entry_queue; +static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor$ * monitors [], __lock_size_t count ) { + + __queue_t(thread$) & entry_queue = monitors[0]->entry_queue; // For each thread in the entry-queue - for( $thread ** thrd_it = &entry_queue.head; + for( thread$ ** thrd_it = &entry_queue.head; (*thrd_it) != 1p; thrd_it = &(*thrd_it)->link.next @@ -972,5 +972,5 @@ } -static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) { +static inline __lock_size_t aggregate( monitor$ * storage [], const __waitfor_mask_t & mask ) { __lock_size_t size = 0; for( __lock_size_t i = 0; i < mask.size; i++ ) { Index: libcfa/src/concurrency/monitor.hfa =================================================================== --- libcfa/src/concurrency/monitor.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/monitor.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -23,9 +23,9 @@ trait is_monitor(T &) { - $monitor * get_monitor( T & ); + monitor$ * get_monitor( T & ); void ^?{}( T & mutex ); }; -static inline void ?{}($monitor & this) with( this ) { +static inline void ?{}(monitor$ & this) with( this ) { lock{}; entry_queue{}; @@ -39,22 +39,22 @@ } -static inline void ^?{}($monitor & ) {} +static inline void ^?{}(monitor$ & ) {} struct monitor_guard_t { - $monitor ** m; + monitor$ ** m; __lock_size_t count; __monitor_group_t prev; }; -void ?{}( monitor_guard_t & this, $monitor ** m, __lock_size_t count, void (*func)() ); +void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() ); void ^?{}( monitor_guard_t & this ); struct monitor_dtor_guard_t { - $monitor * m; + monitor$ * m; __monitor_group_t prev; bool join; }; -void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)(), bool join ); +void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join ); void ^?{}( monitor_dtor_guard_t & this ); @@ -73,5 +73,5 @@ // The monitor this criterion concerns - $monitor * target; + monitor$ * target; // The parent node to which this criterion belongs @@ -88,5 +88,5 @@ struct __condition_node_t { // Thread that needs to be woken when all criteria are met - $thread * waiting_thread; + thread$ * waiting_thread; // Array of criteria (Criterions are contiguous in memory) @@ -107,7 +107,7 @@ } -void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ); +void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info ); void ?{}(__condition_criterion_t & this ); -void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner ); +void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner ); struct condition { @@ -116,5 +116,5 @@ // Array of monitor pointers (Monitors are NOT contiguous in memory) - $monitor ** monitors; + monitor$ ** monitors; // Number of monitors in the array Index: libcfa/src/concurrency/mutex.cfa =================================================================== --- libcfa/src/concurrency/mutex.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/mutex.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -122,5 +122,5 @@ recursion_count--; if( recursion_count == 0 ) { - $thread * thrd = pop_head( blocked_threads ); + thread$ * thrd = pop_head( blocked_threads ); owner = thrd; recursion_count = (thrd ? 1 : 0); Index: libcfa/src/concurrency/mutex.hfa =================================================================== --- libcfa/src/concurrency/mutex.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/mutex.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -36,5 +36,5 @@ // List of blocked threads - __queue_t(struct $thread) blocked_threads; + __queue_t(struct thread$) blocked_threads; // Locked flag @@ -55,8 +55,8 @@ // List of blocked threads - __queue_t(struct $thread) blocked_threads; + __queue_t(struct thread$) blocked_threads; // Current thread owning the lock - struct $thread * owner; + struct thread$ * owner; // Number of recursion level @@ -83,5 +83,5 @@ // List of blocked threads - __queue_t(struct $thread) blocked_threads; + __queue_t(struct thread$) blocked_threads; }; Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/preemption.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -61,5 +61,5 @@ // FwdDeclarations : timeout handlers static void preempt( processor * this ); -static void timeout( $thread * this ); +static void timeout( thread$ * this ); // FwdDeclarations : Signal handlers @@ -420,5 +420,5 @@ // reserved for future use -static void timeout( $thread * this ) { +static void timeout( thread$ * this ) { unpark( this ); } Index: libcfa/src/concurrency/ready_queue.cfa =================================================================== --- libcfa/src/concurrency/ready_queue.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/ready_queue.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -67,7 +67,7 @@ #endif -static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)); -static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)); -static inline struct $thread * search(struct cluster * cltr); +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)); +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)); +static inline struct thread$ * search(struct cluster * cltr); static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred); @@ -274,5 +274,5 @@ //----------------------------------------------------------------------- #if defined(USE_CPU_WORK_STEALING) - __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) { + __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) { __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr); @@ -316,5 +316,5 @@ // Pop from the ready queue from a given cluster - __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); /* paranoid */ verify( kernelTLS().this_processor ); @@ -371,5 +371,5 @@ proc->rdq.target = -1u; if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) { - $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); + thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); proc->rdq.last = target; if(t) return t; @@ -379,5 +379,5 @@ unsigned last = proc->rdq.last; if(last != -1u && lanes.tscs[last].tv < cutoff && ts(lanes.data[last]) < cutoff) { - $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help)); + thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help)); if(t) return t; } @@ -389,5 +389,5 @@ for(READYQ_SHARD_FACTOR) { unsigned i = start + (proc->rdq.itr++ % READYQ_SHARD_FACTOR); - if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; + if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; } @@ -396,9 +396,9 @@ } - __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { processor * const proc = kernelTLS().this_processor; unsigned last = proc->rdq.last; if(last != -1u) { - struct $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal)); + struct thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal)); if(t) return t; proc->rdq.last = -1u; @@ -408,5 +408,5 @@ return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal)); } - __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) { + __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) { return search(cltr); } @@ -435,5 +435,5 @@ } - __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) { + __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) { __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr); @@ -482,5 +482,5 @@ // Pop from the ready queue from a given cluster - __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); /* paranoid */ verify( kernelTLS().this_processor ); @@ -506,5 +506,5 @@ // try popping from the 2 picked lists - struct $thread * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help))); + struct thread$ * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help))); if(thrd) { return thrd; @@ -516,11 +516,11 @@ } - __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) { return pop_fast(cltr); } - __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) { + __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) { return pop_fast(cltr); } + __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) { return search(cltr); } #endif #if defined(USE_WORK_STEALING) - __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) { + __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) { __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr); @@ -576,5 +576,5 @@ // Pop from the ready queue from a given cluster - __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); /* paranoid */ verify( kernelTLS().this_processor ); @@ -598,5 +598,5 @@ const unsigned long long cutoff = proc->rdq.cutoff > bias ? proc->rdq.cutoff - bias : proc->rdq.cutoff; if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) { - $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); + thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); if(t) return t; } @@ -605,15 +605,15 @@ for(READYQ_SHARD_FACTOR) { unsigned i = proc->rdq.id + (proc->rdq.itr++ % READYQ_SHARD_FACTOR); - if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; + if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; } return 0p; } - __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { unsigned i = __tls_rand() % lanes.count; return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal)); } - __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) with (cltr->ready_queue) { return search(cltr); } @@ -628,5 +628,5 @@ //----------------------------------------------------------------------- // try to pop from a lane given by index w -static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { __STATS( stats.attempt++; ) @@ -651,5 +651,5 @@ // Actually pop the list - struct $thread * thrd; + struct thread$ * thrd; unsigned long long tsv; [thrd, tsv] = pop(lane); @@ -678,5 +678,5 @@ // try to pop from any lanes making sure you don't miss any threads push // before the start of the function -static inline struct $thread * search(struct cluster * cltr) with (cltr->ready_queue) { +static inline struct thread$ * search(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED ); @@ -684,5 +684,5 @@ for(i; count) { unsigned idx = (offset + i) % count; - struct $thread * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search)); + struct thread$ * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search)); if(thrd) { return thrd; @@ -719,5 +719,5 @@ //----------------------------------------------------------------------- // Given 2 indexes, pick the list with the oldest push an try to pop from it -static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { // Pick the bet list int w = i; @@ -854,5 +854,5 @@ // As long as we can pop from this lane to push the threads somewhere else in the queue while(!is_empty(lanes.data[idx])) { - struct $thread * thrd; + struct thread$ * thrd; unsigned long long _; [thrd, _] = pop(lanes.data[idx]); Index: libcfa/src/concurrency/ready_subqueue.hfa =================================================================== --- libcfa/src/concurrency/ready_subqueue.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/ready_subqueue.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -7,5 +7,5 @@ // Intrusives lanes which are used by the relaxed ready queue struct __attribute__((aligned(128))) __intrusive_lane_t { - struct $thread * prev; + struct thread$ * prev; // spin lock protecting the queue @@ -20,7 +20,7 @@ // Get the head pointer (one before the first element) from the anchor -static inline $thread * mock_head(const __intrusive_lane_t & this) { - $thread * rhead = ($thread *)( - (uintptr_t)( &this.anchor ) - __builtin_offsetof( $thread, link ) +static inline thread$ * mock_head(const __intrusive_lane_t & this) { + thread$ * rhead = (thread$ *)( + (uintptr_t)( &this.anchor ) - __builtin_offsetof( thread$, link ) ); return rhead; @@ -38,7 +38,7 @@ // We add a boat-load of assertions here because the anchor code is very fragile - /* paranoid */ _Static_assert( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) ); - /* paranoid */ verify( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) ); - /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.anchor) ); + /* paranoid */ _Static_assert( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) ); + /* paranoid */ verify( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) ); + /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, link )) == (uintptr_t)(&this.anchor) ); /* paranoid */ verify( &mock_head(this)->link.next == &this.anchor.next ); /* paranoid */ verify( &mock_head(this)->link.ts == &this.anchor.ts ); @@ -61,5 +61,5 @@ // Push a thread onto this lane // returns true of lane was empty before push, false otherwise -static inline void push( __intrusive_lane_t & this, $thread * node ) { +static inline void push( __intrusive_lane_t & this, thread$ * node ) { /* paranoid */ verify( this.lock ); /* paranoid */ verify( node->link.next == 0p ); @@ -91,5 +91,5 @@ // returns popped // returns true of lane was empty before push, false otherwise -static inline [* $thread, unsigned long long] pop( __intrusive_lane_t & this ) { +static inline [* thread$, unsigned long long] pop( __intrusive_lane_t & this ) { /* paranoid */ verify( this.lock ); /* paranoid */ verify( this.anchor.next != 0p ); @@ -99,5 +99,5 @@ // Get the relevant nodes locally unsigned long long ts = this.anchor.ts; - $thread * node = this.anchor.next; + thread$ * node = this.anchor.next; this.anchor.next = node->link.next; this.anchor.ts = node->link.ts; Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/thread.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -27,5 +27,5 @@ //----------------------------------------------------------------------------- // Thread ctors and dtors -void ?{}($thread & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) { +void ?{}(thread$ & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) { context{ 0p, 0p }; self_cor{ name, storage, storageSize }; @@ -57,5 +57,5 @@ } -void ^?{}($thread& this) with( this ) { +void ^?{}(thread$& this) with( this ) { #if defined( __CFA_WITH_VERIFY__ ) canary = 0xDEADDEADDEADDEADp; @@ -87,6 +87,6 @@ void ?{}( thread_dtor_guard_t & this, T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) { - $monitor * m = get_monitor(thrd); - $thread * desc = get_thread(thrd); + monitor$ * m = get_monitor(thrd); + thread$ * desc = get_thread(thrd); // Setup the monitor guard @@ -130,5 +130,5 @@ forall( T & | is_thread(T) ) void __thrd_start( T & this, void (*main_p)(T &) ) { - $thread * this_thrd = get_thread(this); + thread$ * this_thrd = get_thread(this); disable_interrupts(); Index: libcfa/src/concurrency/thread.hfa =================================================================== --- libcfa/src/concurrency/thread.hfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ libcfa/src/concurrency/thread.hfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -29,5 +29,5 @@ void ^?{}(T& mutex this); void main(T& this); - $thread* get_thread(T& this); + thread$ * get_thread(T& this); }; @@ -45,11 +45,11 @@ // Inline getters for threads/coroutines/monitors forall( T & | is_thread(T) ) -static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; } +static inline coroutine$ * get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; } forall( T & | is_thread(T) ) -static inline $monitor * get_monitor (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; } +static inline monitor$ * get_monitor (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; } -static inline $coroutine* get_coroutine($thread * this) __attribute__((const)) { return &this->self_cor; } -static inline $monitor * get_monitor ($thread * this) __attribute__((const)) { return &this->self_mon; } +static inline coroutine$ * get_coroutine(thread$ * this) __attribute__((const)) { return &this->self_cor; } +static inline monitor$ * get_monitor (thread$ * this) __attribute__((const)) { return &this->self_mon; } //----------------------------------------------------------------------------- @@ -62,16 +62,16 @@ //----------------------------------------------------------------------------- // Ctors and dtors -void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize ); -void ^?{}($thread & this); +void ?{}(thread$ & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize ); +void ^?{}(thread$ & this); -static inline void ?{}($thread & this) { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; } -static inline void ?{}($thread & this, size_t stackSize ) { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; } -static inline void ?{}($thread & this, void * storage, size_t storageSize ) { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; } -static inline void ?{}($thread & this, struct cluster & cl ) { this{ "Anonymous Thread", cl, 0p, 65000 }; } -static inline void ?{}($thread & this, struct cluster & cl, size_t stackSize ) { this{ "Anonymous Thread", cl, 0p, stackSize }; } -static inline void ?{}($thread & this, struct cluster & cl, void * storage, size_t storageSize ) { this{ "Anonymous Thread", cl, storage, storageSize }; } -static inline void ?{}($thread & this, const char * const name) { this{ name, *mainCluster, 0p, 65000 }; } -static inline void ?{}($thread & this, const char * const name, struct cluster & cl ) { this{ name, cl, 0p, 65000 }; } -static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; } +static inline void ?{}(thread$ & this) { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; } +static inline void ?{}(thread$ & this, size_t stackSize ) { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; } +static inline void ?{}(thread$ & this, void * storage, size_t storageSize ) { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; } +static inline void ?{}(thread$ & this, struct cluster & cl ) { this{ "Anonymous Thread", cl, 0p, 65000 }; } +static inline void ?{}(thread$ & this, struct cluster & cl, size_t stackSize ) { this{ "Anonymous Thread", cl, 0p, stackSize }; } +static inline void ?{}(thread$ & this, struct cluster & cl, void * storage, size_t storageSize ) { this{ "Anonymous Thread", cl, storage, storageSize }; } +static inline void ?{}(thread$ & this, const char * const name) { this{ name, *mainCluster, 0p, 65000 }; } +static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl ) { this{ name, cl, 0p, 65000 }; } +static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; } struct thread_dtor_guard_t { @@ -111,5 +111,5 @@ // Unpark a thread, if the thread is already blocked, schedule it // if the thread is not yet block, signal that it should rerun immediately -void unpark( $thread * this ); +void unpark( thread$ * this ); forall( T & | is_thread(T) ) Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ src/Concurrency/Keywords.cc (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -122,7 +122,7 @@ // int data; int data; // a_struct_t more_data; a_struct_t more_data; - // => $thread __thrd_d; + // => thread$ __thrd_d; // }; }; - // static inline $thread * get_thread( MyThread * this ) { return &this->__thrd_d; } + // static inline thread$ * get_thread( MyThread * this ) { return &this->__thrd_d; } // class ThreadKeyword final : public ConcurrentSueKeyword { @@ -130,5 +130,5 @@ ThreadKeyword() : ConcurrentSueKeyword( - "$thread", + "thread$", "__thrd", "get_thread", @@ -155,7 +155,7 @@ // int data; int data; // a_struct_t more_data; a_struct_t more_data; - // => $coroutine __cor_d; + // => coroutine$ __cor_d; // }; }; - // static inline $coroutine * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; } + // static inline coroutine$ * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; } // class CoroutineKeyword final : public ConcurrentSueKeyword { @@ -163,5 +163,5 @@ CoroutineKeyword() : ConcurrentSueKeyword( - "$coroutine", + "coroutine$", "__cor", "get_coroutine", @@ -190,7 +190,7 @@ // int data; int data; // a_struct_t more_data; a_struct_t more_data; - // => $monitor __mon_d; + // => monitor$ __mon_d; // }; }; - // static inline $monitor * get_coroutine( MyMonitor * this ) { return &this->__cor_d; } + // static inline monitor$ * get_coroutine( MyMonitor * this ) { return &this->__cor_d; } // class MonitorKeyword final : public ConcurrentSueKeyword { @@ -198,5 +198,5 @@ MonitorKeyword() : ConcurrentSueKeyword( - "$monitor", + "monitor$", "__mon", "get_monitor", @@ -230,8 +230,8 @@ GeneratorKeyword() : ConcurrentSueKeyword( - "$generator", + "generator$", "__generator_state", "get_generator", - "Unable to find builtin type $generator\n", + "Unable to find builtin type generator$\n", "", true, @@ -292,5 +292,5 @@ //Handles mutex routines definitions : // void foo( A * mutex a, B * mutex b, int i ) { void foo( A * a, B * b, int i ) { - // $monitor * __monitors[] = { get_monitor(a), get_monitor(b) }; + // monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) }; // monitor_guard_t __guard = { __monitors, 2 }; // /*Some code*/ => /*Some code*/ @@ -333,5 +333,5 @@ //Handles mutex routines definitions : // void foo( A * mutex a, B * mutex b, int i ) { void foo( A * a, B * b, int i ) { - // $monitor * __monitors[] = { get_monitor(a), get_monitor(b) }; + // monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) }; // monitor_guard_t __guard = { __monitors, 2 }; // /*Some code*/ => /*Some code*/ @@ -449,5 +449,5 @@ Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) { if ( cast_target == cast->target ) { - // convert (thread &)t to ($thread &)*get_thread(t), etc. + // convert (thread &)t to (thread$ &)*get_thread(t), etc. if( !type_decl ) SemanticError( cast, context_error ); if( !dtor_decl ) SemanticError( cast, context_error ); @@ -919,5 +919,5 @@ void MutexKeyword::postvisit(StructDecl* decl) { - if( decl->name == "$monitor" && decl->body ) { + if( decl->name == "monitor$" && decl->body ) { assert( !monitor_decl ); monitor_decl = decl; @@ -1020,5 +1020,5 @@ ); - //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) }; + //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) }; body->push_front( new DeclStmt( monitors ) ); } @@ -1117,5 +1117,5 @@ ); - //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) }; + //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) }; body->push_front( new DeclStmt( monitors) ); } @@ -1125,5 +1125,5 @@ //============================================================================================= void ThreadStarter::previsit( StructDecl * decl ) { - if( decl->name == "$thread" && decl->body ) { + if( decl->name == "thread$" && decl->body ) { assert( !thread_decl ); thread_decl = decl; Index: src/Concurrency/Waitfor.cc =================================================================== --- src/Concurrency/Waitfor.cc (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ src/Concurrency/Waitfor.cc (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -244,5 +244,5 @@ decl_mask = decl; } - else if( decl->name == "$monitor" ) { + else if( decl->name == "monitor$" ) { assert( !decl_monitor ); decl_monitor = decl; Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ src/ResolvExpr/AlternativeFinder.cc (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1302,5 +1302,5 @@ try { - // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd + // Attempt 1 : turn (thread&)X into (thread$&)X.__thrd // Clone is purely for memory management std::unique_ptr tech1 { new UntypedMemberExpr(new NameExpr(castExpr->concrete_target.field), castExpr->arg->clone()) }; @@ -1313,5 +1313,5 @@ } catch(SemanticErrorException & ) {} - // Fallback : turn (thread&)X into ($thread&)get_thread(X) + // Fallback : turn (thread&)X into (thread$&)get_thread(X) std::unique_ptr fallback { UntypedExpr::createDeref( new UntypedExpr(new NameExpr(castExpr->concrete_target.getter), { castExpr->arg->clone() })) }; // don't prune here, since it's guaranteed all alternatives will have the same type Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ src/ResolvExpr/CandidateFinder.cpp (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -1180,5 +1180,5 @@ try { - // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd + // Attempt 1 : turn (thread&)X into (thread$&)X.__thrd // Clone is purely for memory management std::unique_ptr tech1 { new ast::UntypedMemberExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.field), castExpr->arg) }; @@ -1191,5 +1191,5 @@ } catch(SemanticErrorException & ) {} - // Fallback : turn (thread&)X into ($thread&)get_thread(X) + // Fallback : turn (thread&)X into (thread$&)get_thread(X) std::unique_ptr fallback { ast::UntypedExpr::createDeref(loc, new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) }; // don't prune here, since it's guaranteed all alternatives will have the same type Index: tests/concurrent/semaphore.cfa =================================================================== --- tests/concurrent/semaphore.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tests/concurrent/semaphore.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -22,5 +22,5 @@ void main(Blocker & this) { - $thread * me = active_thread(); + thread$ * me = active_thread(); this.sum = 0; for(num_blocks) { @@ -45,5 +45,5 @@ or else {} - $thread * t = V(ben, false); + thread$ * t = V(ben, false); if(t) { this.sum += (unsigned)t; Index: tests/concurrent/signal/block.cfa =================================================================== --- tests/concurrent/signal/block.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tests/concurrent/signal/block.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -33,6 +33,6 @@ monitor global_data_t { - $thread * last_thread; - $thread * last_signaller; + thread$ * last_thread; + thread$ * last_signaller; }; @@ -82,5 +82,5 @@ if( !is_empty( cond ) ) { - $thread * next = ( $thread * ) front( cond ); + thread$ * next = ( thread$ * ) front( cond ); if( ! signal_block( cond ) ) { Index: tests/concurrent/spinaphore.cfa =================================================================== --- tests/concurrent/spinaphore.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tests/concurrent/spinaphore.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -21,7 +21,7 @@ void main(Blocker & this); -Blocker * from_thread($thread * t) { +Blocker * from_thread(thread$ * t) { Blocker & nullb = *(Blocker*)0p; - $thread & nullt = (thread&)nullb; + thread$ & nullt = (thread&)nullb; uintptr_t offset = (uintptr_t)&nullt; uintptr_t address = ((uintptr_t)t) - offset; @@ -30,5 +30,5 @@ void main(Blocker & this) { - $thread * me = active_thread(); + thread$ * me = active_thread(); Blocker * me1 = &this; Blocker * me2 = from_thread(me); @@ -51,5 +51,5 @@ unsigned me = (unsigned)(uintptr_t)&this; for(num_unblocks) { - $thread * t = V(sem, false); + thread$ * t = V(sem, false); Blocker * b = from_thread(t); b->sum += me; Index: tests/unified_locking/mcs.cfa =================================================================== --- tests/unified_locking/mcs.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tests/unified_locking/mcs.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -7,5 +7,5 @@ struct MutexObj { mcs_lock l; - $thread * id; + thread$ * id; size_t sum; }; @@ -21,5 +21,5 @@ unsigned cs() { - $thread * me = active_thread(); + thread$ * me = active_thread(); unsigned value = (unsigned)me; mcs_node n; Index: tests/unified_locking/thread_test.cfa =================================================================== --- tests/unified_locking/thread_test.cfa (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tests/unified_locking/thread_test.cfa (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -69,5 +69,5 @@ break; default: - break; + break; } processor p[threadCount]; Index: tools/gdb/utils-gdb.py =================================================================== --- tools/gdb/utils-gdb.py (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tools/gdb/utils-gdb.py (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -53,5 +53,5 @@ return CfaTypes(cluster_ptr = gdb.lookup_type('struct cluster').pointer(), processor_ptr = gdb.lookup_type('struct processor').pointer(), - thread_ptr = gdb.lookup_type('struct $thread').pointer(), + thread_ptr = gdb.lookup_type('struct thread$').pointer(), int_ptr = gdb.lookup_type('int').pointer(), thread_state = gdb.lookup_type('enum __Coroutine_State'), @@ -163,8 +163,8 @@ def thread_for_pthread(pthrd): - return tls_for_pthread(pthrd)['_X11this_threadVPS7$thread_1'] + return tls_for_pthread(pthrd)['_X11this_threadVPS7thread$_1'] def thread_for_proc(proc): - return tls_for_proc(proc)['_X11this_threadVPS7$thread_1'] + return tls_for_proc(proc)['_X11this_threadVPS7thread$_1'] @@ -216,5 +216,5 @@ cfa_t = get_cfa_types() - root = cluster['_X7threadsS8__dllist_S7$thread__1']['_X4headPY15__TYPE_generic__1'].cast(cfa_t.thread_ptr) + root = cluster['_X7threadsS8__dllist_S7thread$__1']['_X4headPY15__TYPE_generic__1'].cast(cfa_t.thread_ptr) if root == 0x0 or root.address == 0x0: @@ -313,5 +313,5 @@ )) tls = tls_for_proc( processor ) - thrd = tls['_X11this_threadVPS7$thread_1'] + thrd = tls['_X11this_threadVPS7thread$_1'] if thrd != 0x0: tname = '{} {}'.format(thrd['self_cor']['name'].string(), str(thrd)) Index: tools/perf/process_stat_array.py =================================================================== --- tools/perf/process_stat_array.py (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tools/perf/process_stat_array.py (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -31,5 +31,6 @@ with open(os.path.join(root, filename), 'r') as file: for line in file: - data = [int(x.strip()) for x in line.split(',')] + # data = [int(x.strip()) for x in line.split(',')] + data = [int(line.strip())] data = [me, *data] merged.append(data) @@ -53,5 +54,6 @@ # merge the data -for (me, time, value) in merged: +# for (me, time, value) in merged: +for (me, value) in merged: # check now much this changes old = counters[me] @@ -61,9 +63,30 @@ # add change to the current curr = curr + change - single.append( (time, curr) ) + single.append( value ) pass +print(single) + +# single = sorted(single)[:len(single)-100] +# ms = max(single) +# single = [float(x) / 2500.0 for x in single] + #print -for t, v in single: - print([t, v]) +# for t, v in single: +# print([t, v]) +# print(len(single)) +# print(max(single)) +# print(min(single)) + +# bins = [0, 5.37751600e+04, 1.06903320e+05, 1.60031480e+05, 2.13159640e+05, 2.66287800e+05, 3.19415960e+05, 3.72544120e+05, 4.25672280e+05, 4.78800440e+05, 5.31928600e+05, 5.85056760e+05, 6.38184920e+05, 6.91313080e+05, 7.44441240e+05, 7.97569400e+05, 8.50697560e+05, 9.03825720e+05, 9.56953880e+05, 1.01008204e+06, 1.06321020e+06, 1.11633836e+06, 1.16946652e+06, 1.22259468e+06, 1.27572284e+06, 1.32885100e+06, 1.38197916e+06, 1.43510732e+06, 1.48823548e+06, 1.54136364e+06, 1.59449180e+06, 1.64761996e+06, 1.70074812e+06, 1.75387628e+06, 1.80700444e+06, 1.86013260e+06, 1.91326076e+06, 1.96638892e+06, 2.01951708e+06, 2.07264524e+06, 2.12577340e+06, 2.17890156e+06, 2.23202972e+06, 2.28515788e+06, 2.33828604e+06, 2.39141420e+06, 2.44454236e+06, 2.49767052e+06, 2.55079868e+06, 2.60392684e+06, 3.0e+06] +# # bins = [float(x) / 2500.0 for x in bins] +# # print([round(b, 2) for b in bins]) + +# import numpy +# # hist1, _ = numpy.histogram(single, density=True, bins=50) +# hist2, _ = numpy.histogram(single, density=True, bins=bins) +# # print(hist1) +# print([1000.0 * h for h in hist2]) +# # for v in single: +# # print([v]) Index: tools/vscode/uwaterloo.cforall-0.1.0/syntaxes/cfa.tmLanguage.json =================================================================== --- tools/vscode/uwaterloo.cforall-0.1.0/syntaxes/cfa.tmLanguage.json (revision cf444b64a4a158958376dc2ab509245568729ad6) +++ tools/vscode/uwaterloo.cforall-0.1.0/syntaxes/cfa.tmLanguage.json (revision 6ff08d8fa68f653d45a0ec10f0c2b0d9842f1f2a) @@ -206,5 +206,5 @@ "patterns": [ { "match": "(\\b|^|\\s)(void|bool|char|short|int|long|signed|unsigned|float|double)(\\b|$|\\s)", "name": "storage.type.built-in.primitive.cfa"}, - { "match": "(\\b|^|\\s)(zero_t|one_t|size_t|ssize_t|intptr_t|uintptr_t|\\$thread|\\$coroutine|\\$generator|\\$monitor)(\\b|$|\\s)", "name": "storage.type.built-in.cfa"}, + { "match": "(\\b|^|\\s)(zero_t|one_t|size_t|ssize_t|intptr_t|uintptr_t|thread\\$|coroutine\\$|generator\\$|monitor\\$)(\\b|$|\\s)", "name": "storage.type.built-in.cfa"}, { "match": "(\\b|^|\\s)(extern|static|inline|volatile|const|thread_local)(\\b|$|\\s)", "name": "storage.modifier.cfa"} ]