|
|
DescriptionA tool to evaluate methods in creating temp files
This "CreateTempFilesPerfEval" tool is to compare the time cost of
creating temporary files between using GetTempFileName Windows API and
using the GUID-based method, especially when there are already tens of
thousands of temp files in the target directory.
Sample results from a corp desktop (Windows 10 Enterprise, version
1511) are recorded in GetTempFileNamePerfExample.txt and
GuidPerfExample.txt in this CL. It shows the time cost of creating
every 500 temp files until there are 65535 temp files created in a
directory for each method. The last row shows the time cost of
creating the very last 35 temp files. Note that GetTempFileName can
create at most 65535 files in a single directory.
The sample results (the last row ommited) are also plotted in
https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbLYqyKGE/edit#gid=0
From the data/figure, we can see that GetTempFileName is working fine
when the amount of temp files in the folder is under ~36000. It takes
~400 ms to create 500 temp files. However,
1) As the temp files accumulate to 36500, it performs ~4x worse;
2) As the temp files accumulate to 52000, it performs ~9x worse;
3) As the temp files accumulate to 60000, it performs ~15x worse;
4) As the temp files accumulate to 64500, it performs ~50x worse;
5) As the temp files accumulate to 65000, it performs ~110x worse;
-- Now it takes 43+ seconds to create 500 temp files.
6) As the temp files accumulate to 65500, it performs ~1570x worse;
-- It takes 44+ seconds just to create the remaining 35 temp files.
In comparison, creating temp files using GUID-based method doesn't
have this performance issue. It always takes 400 ms ~ 500 ms to create
500 temp files. The time complexity of GUID-based method for creating
temp files is O(1) w.r.t the amount of existing temp files in the
target directory.
BUG=711534, 103737
Review-Url: https://codereview.chromium.org/2810333008
Cr-Commit-Position: refs/heads/master@{#465438}
Committed: https://chromium.googlesource.com/chromium/src/+/4cb75df89a5fabfb4a83717cdc0f9289eb3b0596
Patch Set 1 #
Total comments: 7
Patch Set 2 : Use TEMP directory, delete all created temp folder/files automatically #
Total comments: 15
Patch Set 3 : Address comments #Patch Set 4 : Fix evaluation of execution time for CreateFilesUsingGuid #Patch Set 5 : Better printf to make the output more readable #
Messages
Total messages: 104 (89 generated)
Description was changed from ========== BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ==========
Patchset #2 (id:20001) has been deleted
Patchset #1 (id:1) has been deleted
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ==========
Patchset #1 (id:40001) has been deleted
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ==========
chengx@chromium.org changed reviewers: + brucedawson@chromium.org
PTAL~
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and Guid method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ==========
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Patchset #1 (id:60001) has been deleted
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
chengx@chromium.org changed reviewers: + stanisc@chromium.org
Adding Stan. PTAL~
The CQ bit was unchecked by commit-bot@chromium.org
Dry run: This issue passed the CQ dry run.
This is a great experiments that shows that we should consider switching to a GUID based method of generating temp files in Chrome. However to me this looks like a one time experiment and I am not sure if anyone would want to re-use this tool again, especially once we've done the conversion to the new format. Here is another random thought. The MAX_PATH limit is still 260 characters. With much longer GUID based temp file name there is an increased risk of running out of it which may introduce some subtle bugs. Just keep this in mind. https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:41: CHAR kTempDirForGuid[] = "C:\\src\\TempDirGuid\\"; If you want to make the tool reusable it shouldn't rely on a predefined C:\src directory. It could use either current directory or TEMP directory for the output. https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:173: out += sprintf(out, "%.2hhX", id->Data4[i]); Could use cast Data4 to to avoid printing byte by byte. https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... File tools/win/CreateTempFilesPerfEvaluation/ReadMe.txt (right): https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/ReadMe.txt:43: Delete all those created temp files! They won't be deleted by the program Why doesn't the tool delete all those temp files at the end of measurement. What's the point of keeping the files?
https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:173: out += sprintf(out, "%.2hhX", id->Data4[i]); On 2017/04/14 18:46:00, stanisc wrote: > Could use cast Data4 to to avoid printing byte by byte. What I was really trying to say is: Could this try to cast Data4 to ULONGLONG to avoid printing byte by byte?
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
The CQ bit was unchecked by commit-bot@chromium.org
Dry run: This issue passed the CQ dry run.
Patchset #2 (id:100001) has been deleted
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
Patchset #2 (id:120001) has been deleted
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
On 2017/04/14 18:46:00, stanisc wrote: > This is a great experiments that shows that we should consider switching to a > GUID based method of generating temp files in Chrome. However to me this looks > like a one time experiment and I am not sure if anyone would want to re-use this > tool again, especially once we've done the conversion to the new format. Actually, I have updated CreateTemporaryFileInDir() to use GUID based method already, as in crrev.com/2788483005. But I think we have more places that need this update. I was reluctant to check in the tool initially, but then I realized I need to check it it. One reason is that it won't be gone due to random reasons such as I delete it occasionally or disk failures. More importantly, if others doubt the reported experimental results, they can run the tool themselves. They may also want to improve this tool to do more experiments, e.g., they can supply a random 3-digit prefix to GetTempFileName API to see its performance. https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:41: CHAR kTempDirForGuid[] = "C:\\src\\TempDirGuid\\"; On 2017/04/14 18:45:59, stanisc wrote: > If you want to make the tool reusable it shouldn't rely on a predefined C:\src > directory. It could use either current directory or TEMP directory for the > output. Thanks for the reminder. I have switched to the TEMP directory. https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:173: out += sprintf(out, "%.2hhX", id->Data4[i]); On 2017/04/14 18:47:58, stanisc wrote: > On 2017/04/14 18:46:00, stanisc wrote: > > Could use cast Data4 to to avoid printing byte by byte. > > What I was really trying to say is: Could this try to cast Data4 to ULONGLONG to > avoid printing byte by byte? Em, I am not sure but I will try. I think the current way is working fine though. https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... File tools/win/CreateTempFilesPerfEvaluation/ReadMe.txt (right): https://codereview.chromium.org/2810333008/diff/80001/tools/win/CreateTempFil... tools/win/CreateTempFilesPerfEvaluation/ReadMe.txt:43: Delete all those created temp files! They won't be deleted by the program On 2017/04/14 18:46:00, stanisc wrote: > Why doesn't the tool delete all those temp files at the end of measurement. > What's the point of keeping the files? Good point! I have added folder+file deletion in the new patch set.
The CQ bit was unchecked by commit-bot@chromium.org
Dry run: This issue passed the CQ dry run.
Patchset #3 (id:160001) has been deleted
This is very useful information, worth sharing. However: 1) You should put the conclusions in the CL description - describe the performance of both methods. 2) You should graph the results in a publicly visible chromium.org sheets.google.com document. Link to it from the CL description, and vice-versa. 3) Mention in the CL description that some sample raw numbers are in some of the CL files, to make sure people find them. 4) You should test on some non-corp machines - or just different machines - to see if any of the conclusions change. I don't expect they will but if you test on multiple machines (multiple OS versions?) then you can make stronger claims. 5) For bonus points run this on Linux and OSX. If you are going to give guidance to Chrome developers then they will want to know what to do on all platforms. Note also that one critique of the GUID method that I saw in an earlier CL was the possibility of name collisions. If you get a name collision from a GUID then either your GUID generator is broken or else a cosmic-ray caused the CPU to take the wrong branch when checking for a collision. An actual collision should never (in the lifetime of the universe) occur. See the top answer to this question: http://stackoverflow.com/questions/2977593/is-it-safe-to-assume-a-guid-will-a... https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/GetTempFileNamePerfExample.txt (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/GetTempFileNamePerfExample.txt:2: 500 / 65500 --- 390 ms The first number should be printed with %5d so that the columns line up. Arguably the number of ms should also be printed with %5d, to make it easier to column select. Or you could print the units at the top of the column and omit them elsewhere.
https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:183: std::cout << i << " / " << count << " --- " << elapsed_ms.QuadPart Printing out to the console takes some non-trivial time. It would be better to take a new time snapshot after this line to exclude the console printing time. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:202: bool IsDirectoryReadyExistedAndEmpty(const char* folder_path) { The function name is somewhat confusing. Please consider renaming it something like CreateOrValidateTempDirectory. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:219: char fileFound[256]; Use MAX_PATH instead. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:226: (strcmp(info.cFileName, "..") == 0))) { I suggest using a pattern where you skip these files and continue i.e. if (strcmp(info.cFileName, ".") == 0 || strcmp(info.cFileName, "..") == 0) { continue; } Also this doesn't need some of the parenthesis. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:228: FILE_ATTRIBUTE_DIRECTORY) { Do you really expect nested directories there? You tool doesn't create any nested directories so perhaps it shouldn't delete them. Also since your tool creates only *.tmp file perhaps it should delete only files with that extension. Better be safe when deleting anything from the disk.
https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:228: FILE_ATTRIBUTE_DIRECTORY) { On 2017/04/14 23:30:55, stanisc wrote: > Do you really expect nested directories there? You tool doesn't create any > nested directories so perhaps it shouldn't delete them. Also since your tool > creates only *.tmp file perhaps it should delete only files with that extension. > Better be safe when deleting anything from the disk. Or, when creating files track the names and then delete exactly the files that you created. A std::vector<std::string> that you resize to 65536 at the beginning should not affect the results significantly (and should have a constant-time effect anyway) and would then make the deletion code trivial.
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. 1) You should put the conclusions in the CL description - describe the performance of both methods. 2) You should graph the results in a publicly visible chromium.org sheets.google.com document. Link to it from the CL description, and vice-versa. 3) Mention in the CL description that some sample raw numbers are in some of the CL files, to make sure people find them. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. 1) You should put the conclusions in the CL description - describe the performance of both methods. 2) You should graph the results in a publicly visible chromium.org sheets.google.com document. Link to it from the CL description, and vice-versa. 3) Mention in the CL description that some sample raw numbers are in some of the CL files, to make sure people find them. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. The sample results are also visualized in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, ... BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temporary files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. The sample results are also visualized in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, ... BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. The sample results are also visualized in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, ... BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName() Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. The sample results are also visualized in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, ... BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1cAB2yCY3y48uYrFsL0F0SDCvKpPpfzeryqOvP... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName() and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Patchset #3 (id:180001) has been deleted
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop are recorded in GuidPerfExample.txt and GetTempFileNamePerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop are recorded in GuidPerfExample.txt and GetTempFileNamePerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop are recorded in GuidPerfExample.txt and GetTempFileNamePerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop are recorded in GuidPerfExample.txt and GetTempFileNamePerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop are recorded in GuidPerfExample.txt and GetTempFileNamePerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
The CQ bit was unchecked by commit-bot@chromium.org
Dry run: This issue passed the CQ dry run.
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop are recorded in GuidPerfExample.txt and GetTempFileNamePerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ==========
To Stan & Bruce: all code comments are addressed in the new patch set. To Bruce: > 1) You should put the conclusions in the CL description - describe the > performance of both methods. Done. > 2) You should graph the results in a publicly visible http://chromium.org > http://sheets.google.com document. Link to it from the CL description, and vice-versa. Done. > 3) Mention in the CL description that some sample raw numbers are in some of the > CL files, to make sure people find them. Done. > 4) You should test on some non-corp machines - or just different machines - to > see if any of the conclusions change. I don't expect they will but if you test > on multiple machines (multiple OS versions?) then you can make stronger claims. Maybe I should check in the tool first so that Stan can check it out and help run it on his Windows 7 machine. > 5) For bonus points run this on Linux and OSX. If you are going to give guidance > to Chrome developers then they will want to know what to do on all platforms. I think mkstemp method is used for non-Windows platforms. https://cs.chromium.org/webrtc/src/base/files/file_util_posix.cc?type=cs&q=Cr... I've read its documentation. It's non-GUID based but it should perform better than GetTempFileName. I'll evaluate its performance on my Linux machine, but it might be unrelated to this CL. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:183: std::cout << i << " / " << count << " --- " << elapsed_ms.QuadPart On 2017/04/14 23:30:54, stanisc wrote: > Printing out to the console takes some non-trivial time. It would be better to > take a new time snapshot after this line to exclude the console printing time. You're right! Done. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:202: bool IsDirectoryReadyExistedAndEmpty(const char* folder_path) { On 2017/04/14 23:30:54, stanisc wrote: > The function name is somewhat confusing. Please consider renaming it something > like CreateOrValidateTempDirectory. Done. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:219: char fileFound[256]; On 2017/04/14 23:30:54, stanisc wrote: > Use MAX_PATH instead. Done. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:226: (strcmp(info.cFileName, "..") == 0))) { On 2017/04/14 23:30:55, stanisc wrote: > I suggest using a pattern where you skip these files and continue i.e. > if (strcmp(info.cFileName, ".") == 0 || > strcmp(info.cFileName, "..") == 0) { > continue; > } > Also this doesn't need some of the parenthesis. Done. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:228: FILE_ATTRIBUTE_DIRECTORY) { On 2017/04/14 23:30:55, stanisc wrote: > Do you really expect nested directories there? You tool doesn't create any > nested directories so perhaps it shouldn't delete them. Also since your tool > creates only *.tmp file perhaps it should delete only files with that extension. > Better be safe when deleting anything from the disk. Agree that sub-directories won't be created, so I will remove the related code. Since all the .tmp files are created in a temporary folder created by this program, I'll just delete the folder including all its contents. It won't delete anything not created by this program. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/GetTempFileNamePerfExample.txt (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/GetTempFileNamePerfExample.txt:2: 500 / 65500 --- 390 ms On 2017/04/14 23:07:24, brucedawson wrote: > The first number should be printed with %5d so that the columns line up. > > Arguably the number of ms should also be printed with %5d, to make it easier to > column select. Or you could print the units at the top of the column and omit > them elsewhere. Done.
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:183: std::cout << i << " / " << count << " --- " << elapsed_ms.QuadPart On 2017/04/17 19:00:57, chengx wrote: > On 2017/04/14 23:30:54, stanisc wrote: > > Printing out to the console takes some non-trivial time. It would be better to > > take a new time snapshot after this line to exclude the console printing time. > > You're right! Done. The same issue still exists in CreateFilesUsingGuid
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes 15x worse. When the amount hits about 64500, the performance becomes 65x worse suddenly. When the amount hits about 65000, the performance becomes 100x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes ~16x worse. When the amount hits about 64500, the performance becomes ~44x worse suddenly. When the amount hits about 65000, the performance becomes ~125x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
The evaluation of execution time is fixed for CreateFilesUsingGuid in the new patch set. Also, sample results and their visualization are updated after this fix. https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... File tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc (right): https://codereview.chromium.org/2810333008/diff/140001/tools/win/CreateTempFi... tools/win/CreateTempFilesPerfEvaluation/CreateTempFilesPerfEval.cc:183: std::cout << i << " / " << count << " --- " << elapsed_ms.QuadPart On 2017/04/17 22:36:09, stanisc wrote: > On 2017/04/17 19:00:57, chengx wrote: > > On 2017/04/14 23:30:54, stanisc wrote: > > > Printing out to the console takes some non-trivial time. It would be better > to > > > take a new time snapshot after this line to exclude the console printing > time. > > > > You're right! Done. > > The same issue still exists in CreateFilesUsingGuid Ah, I forgot. Now it's fixed.
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. As the temp files keep accumulating to 60000, GetTempFileName's performance becomes ~16x worse. When the amount hits about 64500, the performance becomes ~44x worse suddenly. When the amount hits about 65000, the performance becomes ~125x worse where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. 1) As the temp files accumulates to 3600, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse, where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. 1) As the temp files accumulates to 3600, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse, where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse, where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse, where it takes about 40 seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Finally it takes 50+ seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Finally it takes 50+ seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Finally it takes 50+ seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under about 36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Finally it takes 50+ seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Finally it takes 50+ seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65500 temp files created in a directory for each method. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Finally it takes 50+ seconds to create 500 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Now it takes 50+ seconds to create 500 temp files. 5) Finally it takes 54+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36000, the performance is ~3.5x worse; 2) As the temp files accumulates to 52500, the performance is ~10x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~44x worse; 5) As the temp files accumulates to 65000, the performance is ~125x worse. Now it takes 50+ seconds to create 500 temp files. 5) Finally it takes 54+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~45x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse. Now it takes 50+ seconds to create 500 temp files. 5) Finally it takes 54+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~45x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse. Now it takes 50+ seconds to create 500 temp files. 5) Finally it takes 54+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse. Now it takes 43+ seconds to create 500 temp files. 5) Finally it takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse. Now it takes 43+ seconds to create 500 temp files. 5) Finally it takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse. Now it takes 43+ seconds to create 500 temp files. 6) Finally, it takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse. Now it takes 43+ seconds to create 500 temp files. 6) Finally, it takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) Finally, it takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) Finally, it takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) As the temp files accumulates to 65000, the performance is ~1570x worse (Finally, it takes 44+ seconds just to create the remaining 35 temp files). In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) As the temp files accumulates to 65000, the performance is ~1570x worse (Finally, it takes 44+ seconds just to create the remaining 35 temp files). In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) As the temp files accumulates to 65500, the performance is ~1570x worse (Finally, it takes 44+ seconds just to create the remaining 35 temp files). In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) As the temp files accumulates to 65500, the performance is ~1570x worse (Finally, it takes 44+ seconds just to create the remaining 35 temp files). In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) As the temp files accumulates to 65500, the performance is ~1570x worse (It takes 44+ seconds just to create the remaining 35 temp files). In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse (Now it takes 43+ seconds to create 500 temp files); 6) As the temp files accumulates to 65500, the performance is ~1570x worse (It takes 44+ seconds just to create the remaining 35 temp files). In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulates to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
The CQ bit was unchecked by commit-bot@chromium.org
Dry run: This issue passed the CQ dry run.
lgtm
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulates to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulates to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulates to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulates to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulates to 36500, the performance is ~4x worse; 2) As the temp files accumulates to 52000, the performance is ~9x worse; 3) As the temp files accumulates to 60000, the performance is ~15x worse; 4) As the temp files accumulates to 64500, the performance is ~50x worse; 5) As the temp files accumulates to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulates to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, the performance is ~4x worse; 2) As the temp files accumulate to 52000, the performance is ~9x worse; 3) As the temp files accumulate to 60000, the performance is ~15x worse; 4) As the temp files accumulate to 64500, the performance is ~50x worse; 5) As the temp files accumulate to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, the performance is ~4x worse; 2) As the temp files accumulate to 52000, the performance is ~9x worse; 3) As the temp files accumulate to 60000, the performance is ~15x worse; 4) As the temp files accumulate to 64500, the performance is ~50x worse; 5) As the temp files accumulate to 65000, the performance is ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, the performance is ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
The CQ bit was checked by chengx@chromium.org to run a CQ dry run
Dry run: CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
The CQ bit was unchecked by commit-bot@chromium.org
Dry run: This issue passed the CQ dry run.
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate GetTempFileName API and GUID method in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate different methods creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate different methods creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== CreateTempFilesPerfEval tool to evaluate methods in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Description was changed from ========== CreateTempFilesPerfEval tool to evaluate methods in creating temp files This tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== A tool to evaluate methods in creating temp files This "CreateTempFilesPerfEval" tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ==========
Patchset #5 (id:240001) has been deleted
The CQ bit was checked by chengx@chromium.org
The patchset sent to the CQ was uploaded after l-g-t-m from stanisc@chromium.org Link to the patchset: https://codereview.chromium.org/2810333008/#ps260001 (title: "Better printf to make the output more readable")
CQ is trying da patch. Follow status at https://chromium-cq-status.appspot.com/v2/patch-status/codereview.chromium.or...
lgtm
CQ is committing da patch. Bot data: {"patchset_id": 260001, "attempt_start_ts": 1492561036936460, "parent_rev": "1e2d5ea4965411024f7682ce7c441ab38239263f", "commit_rev": "4cb75df89a5fabfb4a83717cdc0f9289eb3b0596"}
Message was sent while issue was closed.
Description was changed from ========== A tool to evaluate methods in creating temp files This "CreateTempFilesPerfEval" tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 ========== to ========== A tool to evaluate methods in creating temp files This "CreateTempFilesPerfEval" tool is to compare the time cost of creating temporary files between using GetTempFileName Windows API and using the GUID-based method, especially when there are already tens of thousands of temp files in the target directory. Sample results from a corp desktop (Windows 10 Enterprise, version 1511) are recorded in GetTempFileNamePerfExample.txt and GuidPerfExample.txt in this CL. It shows the time cost of creating every 500 temp files until there are 65535 temp files created in a directory for each method. The last row shows the time cost of creating the very last 35 temp files. Note that GetTempFileName can create at most 65535 files in a single directory. The sample results (the last row ommited) are also plotted in https://docs.google.com/spreadsheets/d/1j5nHneABic4-Ziz7KjjXPAbvr2aERyZB0qwbL... From the data/figure, we can see that GetTempFileName is working fine when the amount of temp files in the folder is under ~36000. It takes ~400 ms to create 500 temp files. However, 1) As the temp files accumulate to 36500, it performs ~4x worse; 2) As the temp files accumulate to 52000, it performs ~9x worse; 3) As the temp files accumulate to 60000, it performs ~15x worse; 4) As the temp files accumulate to 64500, it performs ~50x worse; 5) As the temp files accumulate to 65000, it performs ~110x worse; -- Now it takes 43+ seconds to create 500 temp files. 6) As the temp files accumulate to 65500, it performs ~1570x worse; -- It takes 44+ seconds just to create the remaining 35 temp files. In comparison, creating temp files using GUID-based method doesn't have this performance issue. It always takes 400 ms ~ 500 ms to create 500 temp files. The time complexity of GUID-based method for creating temp files is O(1) w.r.t the amount of existing temp files in the target directory. BUG=711534,103737 Review-Url: https://codereview.chromium.org/2810333008 Cr-Commit-Position: refs/heads/master@{#465438} Committed: https://chromium.googlesource.com/chromium/src/+/4cb75df89a5fabfb4a83717cdc0f... ==========
Message was sent while issue was closed.
Committed patchset #5 (id:260001) as https://chromium.googlesource.com/chromium/src/+/4cb75df89a5fabfb4a83717cdc0f... |