Mercurial > cpython-lru_cache-weakref
annotate PCbuild/kill_python.c @ 87690:66c1c9f32567 default tip
Add use_weakref option to functools.lru_cache
The use_weakref option makes lru_cache create weak references to the function
arguments when creating the cache key, which prevents them from staying in the
memory forever even after all other references to them are gone.
This is a proof of concept for http://bugs.python.org/issue19859
| author | Radomir Dopieralski <devel@sheep.art.pl> |
|---|---|
| date | Tue, 03 Dec 2013 16:02:48 +0100 |
| parents | 1085b0e475d8 |
| children |
| rev | line source |
|---|---|
| 47705 | 1 /* |
| 2 * Helper program for killing lingering python[_d].exe processes before | |
| 3 * building, thus attempting to avoid build failures due to files being | |
| 4 * locked. | |
| 5 */ | |
| 6 | |
| 7 #include <windows.h> | |
| 8 #include <wchar.h> | |
| 9 #include <tlhelp32.h> | |
| 10 #include <stdio.h> | |
| 11 | |
| 12 #pragma comment(lib, "psapi") | |
| 13 | |
| 14 #ifdef _DEBUG | |
| 15 #define PYTHON_EXE (L"python_d.exe") | |
| 16 #define PYTHON_EXE_LEN (12) | |
| 17 #define KILL_PYTHON_EXE (L"kill_python_d.exe") | |
| 18 #define KILL_PYTHON_EXE_LEN (17) | |
| 19 #else | |
| 20 #define PYTHON_EXE (L"python.exe") | |
| 21 #define PYTHON_EXE_LEN (10) | |
| 22 #define KILL_PYTHON_EXE (L"kill_python.exe") | |
| 23 #define KILL_PYTHON_EXE_LEN (15) | |
| 24 #endif | |
| 25 | |
| 26 int | |
| 27 main(int argc, char **argv) | |
| 28 { | |
| 29 HANDLE hp, hsp, hsm; /* process, snapshot processes, snapshot modules */ | |
| 30 DWORD dac, our_pid; | |
| 31 size_t len; | |
| 32 wchar_t path[MAX_PATH+1]; | |
| 33 | |
| 34 MODULEENTRY32W me; | |
| 35 PROCESSENTRY32W pe; | |
| 36 | |
| 37 me.dwSize = sizeof(MODULEENTRY32W); | |
| 38 pe.dwSize = sizeof(PROCESSENTRY32W); | |
| 39 | |
| 40 memset(path, 0, MAX_PATH+1); | |
| 41 | |
| 42 our_pid = GetCurrentProcessId(); | |
| 43 | |
| 44 hsm = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, our_pid); | |
| 45 if (hsm == INVALID_HANDLE_VALUE) { | |
| 46 printf("CreateToolhelp32Snapshot[1] failed: %d\n", GetLastError()); | |
| 47 return 1; | |
| 48 } | |
| 49 | |
| 50 if (!Module32FirstW(hsm, &me)) { | |
| 51 printf("Module32FirstW[1] failed: %d\n", GetLastError()); | |
| 52 CloseHandle(hsm); | |
| 53 return 1; | |
| 54 } | |
| 55 | |
| 56 /* | |
| 57 * Enumerate over the modules for the current process in order to find | |
| 58 * kill_process[_d].exe, then take a note of the directory it lives in. | |
| 59 */ | |
| 60 do { | |
| 61 if (_wcsnicmp(me.szModule, KILL_PYTHON_EXE, KILL_PYTHON_EXE_LEN)) | |
| 62 continue; | |
| 63 | |
| 64 len = wcsnlen_s(me.szExePath, MAX_PATH) - KILL_PYTHON_EXE_LEN; | |
| 65 wcsncpy_s(path, MAX_PATH+1, me.szExePath, len); | |
| 66 | |
| 67 break; | |
| 68 | |
| 69 } while (Module32NextW(hsm, &me)); | |
| 70 | |
| 71 CloseHandle(hsm); | |
| 72 | |
| 73 if (path == NULL) { | |
| 74 printf("failed to discern directory of running process\n"); | |
| 75 return 1; | |
| 76 } | |
| 77 | |
| 78 /* | |
| 79 * Take a snapshot of system processes. Enumerate over the snapshot, | |
| 80 * looking for python processes. When we find one, verify it lives | |
| 81 * in the same directory we live in. If it does, kill it. If we're | |
| 82 * unable to kill it, treat this as a fatal error and return 1. | |
| 83 * | |
| 84 * The rationale behind this is that we're called at the start of the | |
| 85 * build process on the basis that we'll take care of killing any | |
| 86 * running instances, such that the build won't encounter permission | |
| 87 * denied errors during linking. If we can't kill one of the processes, | |
| 88 * we can't provide this assurance, and the build shouldn't start. | |
| 89 */ | |
| 90 | |
| 91 hsp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); | |
| 92 if (hsp == INVALID_HANDLE_VALUE) { | |
| 93 printf("CreateToolhelp32Snapshot[2] failed: %d\n", GetLastError()); | |
| 94 return 1; | |
| 95 } | |
| 96 | |
| 97 if (!Process32FirstW(hsp, &pe)) { | |
| 98 printf("Process32FirstW failed: %d\n", GetLastError()); | |
| 99 CloseHandle(hsp); | |
| 100 return 1; | |
| 101 } | |
| 102 | |
| 103 dac = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_TERMINATE; | |
| 104 do { | |
| 105 | |
| 106 /* | |
| 107 * XXX TODO: if we really wanted to be fancy, we could check the | |
| 108 * modules for all processes (not just the python[_d].exe ones) | |
|
79240
1085b0e475d8
Bump version to 3.4.0 alpha 0.
Georg Brandl <georg@python.org>
parents:
68071
diff
changeset
|
109 * and see if any of our DLLs are loaded (i.e. python34[_d].dll), |
| 47705 | 110 * as that would also inhibit our ability to rebuild the solution. |
| 111 * Not worth loosing sleep over though; for now, a simple check | |
| 112 * for just the python executable should be sufficient. | |
| 113 */ | |
| 114 | |
| 115 if (_wcsnicmp(pe.szExeFile, PYTHON_EXE, PYTHON_EXE_LEN)) | |
| 116 /* This isn't a python process. */ | |
| 117 continue; | |
| 118 | |
| 119 /* It's a python process, so figure out which directory it's in... */ | |
| 120 hsm = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pe.th32ProcessID); | |
| 121 if (hsm == INVALID_HANDLE_VALUE) | |
| 122 /* | |
| 123 * If our module snapshot fails (which will happen if we don't own | |
| 124 * the process), just ignore it and continue. (It seems different | |
| 125 * versions of Windows return different values for GetLastError() | |
| 126 * in this situation; it's easier to just ignore it and move on vs. | |
| 127 * stopping the build for what could be a false positive.) | |
| 128 */ | |
| 129 continue; | |
| 130 | |
| 131 if (!Module32FirstW(hsm, &me)) { | |
| 132 printf("Module32FirstW[2] failed: %d\n", GetLastError()); | |
| 133 CloseHandle(hsp); | |
| 134 CloseHandle(hsm); | |
| 135 return 1; | |
| 136 } | |
| 137 | |
| 138 do { | |
| 139 if (_wcsnicmp(me.szModule, PYTHON_EXE, PYTHON_EXE_LEN)) | |
| 140 /* Wrong module, we're looking for python[_d].exe... */ | |
| 141 continue; | |
| 142 | |
| 143 if (_wcsnicmp(path, me.szExePath, len)) | |
| 144 /* Process doesn't live in our directory. */ | |
| 145 break; | |
| 146 | |
| 147 /* Python process residing in the right directory, kill it! */ | |
| 148 hp = OpenProcess(dac, FALSE, pe.th32ProcessID); | |
| 149 if (!hp) { | |
| 150 printf("OpenProcess failed: %d\n", GetLastError()); | |
| 151 CloseHandle(hsp); | |
| 152 CloseHandle(hsm); | |
| 153 return 1; | |
| 154 } | |
| 155 | |
| 156 if (!TerminateProcess(hp, 1)) { | |
| 157 printf("TerminateProcess failed: %d\n", GetLastError()); | |
| 158 CloseHandle(hsp); | |
| 159 CloseHandle(hsm); | |
| 160 CloseHandle(hp); | |
| 161 return 1; | |
| 162 } | |
| 163 | |
| 164 CloseHandle(hp); | |
| 165 break; | |
| 166 | |
| 167 } while (Module32NextW(hsm, &me)); | |
| 168 | |
| 169 CloseHandle(hsm); | |
| 170 | |
| 171 } while (Process32NextW(hsp, &pe)); | |
| 172 | |
| 173 CloseHandle(hsp); | |
| 174 | |
| 175 return 0; | |
| 176 } | |
| 177 | |
| 178 /* vi: set ts=8 sw=4 sts=4 expandtab */ |