OLD | NEW |
1 // Copyright 2006-2008 the V8 project authors. All rights reserved. | 1 // Copyright 2006-2008 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 21 matching lines...) Expand all Loading... |
32 #include <unistd.h> // for usleep() | 32 #include <unistd.h> // for usleep() |
33 | 33 |
34 #include "v8.h" | 34 #include "v8.h" |
35 | 35 |
36 #include "platform.h" | 36 #include "platform.h" |
37 #include "cctest.h" | 37 #include "cctest.h" |
38 | 38 |
39 using namespace ::v8::internal; | 39 using namespace ::v8::internal; |
40 | 40 |
41 | 41 |
42 static void yield() { | |
43 usleep(1); | |
44 } | |
45 | |
46 static const int kLockCounterLimit = 50; | |
47 static int busy_lock_counter = 0; | |
48 | |
49 | |
50 static void LoopIncrement(Mutex* mutex, int rem) { | |
51 while (true) { | |
52 int count = 0; | |
53 int last_count = -1; | |
54 do { | |
55 LockGuard<Mutex> lock_guard(mutex); | |
56 count = busy_lock_counter; | |
57 yield(); | |
58 } while (count % 2 == rem && count < kLockCounterLimit); | |
59 if (count >= kLockCounterLimit) break; | |
60 LockGuard<Mutex> lock_guard(mutex); | |
61 CHECK_EQ(count, busy_lock_counter); | |
62 CHECK(last_count == -1 || count == last_count + 1); | |
63 busy_lock_counter++; | |
64 last_count = count; | |
65 yield(); | |
66 } | |
67 } | |
68 | |
69 | |
70 static void* RunTestBusyLock(void* arg) { | |
71 LoopIncrement(static_cast<Mutex*>(arg), 0); | |
72 return 0; | |
73 } | |
74 | |
75 | |
76 // Runs two threads that repeatedly acquire the lock and conditionally | |
77 // increment a variable. | |
78 TEST(BusyLock) { | |
79 pthread_t other; | |
80 Mutex mutex; | |
81 int thread_created = pthread_create(&other, | |
82 NULL, | |
83 &RunTestBusyLock, | |
84 &mutex); | |
85 CHECK_EQ(0, thread_created); | |
86 LoopIncrement(&mutex, 1); | |
87 pthread_join(other, NULL); | |
88 } | |
89 | |
90 | |
91 TEST(VirtualMemory) { | 42 TEST(VirtualMemory) { |
92 OS::SetUp(); | 43 OS::SetUp(); |
93 VirtualMemory* vm = new VirtualMemory(1 * MB); | 44 VirtualMemory* vm = new VirtualMemory(1 * MB); |
94 CHECK(vm->IsReserved()); | 45 CHECK(vm->IsReserved()); |
95 void* block_addr = vm->address(); | 46 void* block_addr = vm->address(); |
96 size_t block_size = 4 * KB; | 47 size_t block_size = 4 * KB; |
97 CHECK(vm->Commit(block_addr, block_size, false)); | 48 CHECK(vm->Commit(block_addr, block_size, false)); |
98 // Check whether we can write to memory. | 49 // Check whether we can write to memory. |
99 int* addr = static_cast<int*>(block_addr); | 50 int* addr = static_cast<int*>(block_addr); |
100 addr[KB-1] = 2; | 51 addr[KB-1] = 2; |
101 CHECK(vm->Uncommit(block_addr, block_size)); | 52 CHECK(vm->Uncommit(block_addr, block_size)); |
102 delete vm; | 53 delete vm; |
103 } | 54 } |
104 | 55 |
105 | 56 |
106 TEST(GetCurrentProcessId) { | 57 TEST(GetCurrentProcessId) { |
107 OS::SetUp(); | 58 OS::SetUp(); |
108 CHECK_EQ(static_cast<int>(getpid()), OS::GetCurrentProcessId()); | 59 CHECK_EQ(static_cast<int>(getpid()), OS::GetCurrentProcessId()); |
109 } | 60 } |
OLD | NEW |