rewrite_to_chrome_style: Add a lock file when writing replacements.

tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Changes Blink-style names to Chrome-style names. Currently transforms:
 //   fields:
 //     int m_operationCount => int operation_count_
 //   variables (including parameters):
 //     int mySuperVariable => int my_super_variable
 //   constants:
 //     const int maxThings => const int kMaxThings
 //   free functions and methods:
 //     void doThisThenThat() => void DoThisAndThat()
 
 #include <assert.h>
+#include <string.h>
 #include <algorithm>
 #include <fstream>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <sys/file.h>
+#include <unistd.h>
+#endif
+
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
@@ skipping 471 matching lines @@
       &replacements);
   match_finder.addMatcher(constructor_initializer_matcher,
                           &constructor_initializer_rewriter);
 
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
       clang::tooling::newFrontendActionFactory(&match_finder);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
+#if defined(_WIN32)
+  OFSTRUCT lockfd_out;
+  HFILE lockfd = OpenFile("rewrite-sym.lock", &lockfd_out, OF_CREATE);
+  OVERLAPPED lock_out;
+  memset(&lock_out, 0, sizeof(lock_out));

[dcheng, 2016/01/22 00:31:30]

OVERLAPPED lock_out = {};

then you can skip the memset.

[danakj, 2016/01/22 23:33:36]

Fancy~

+  LockFileEx(lockfd, LOCKFILE_EXCLUSIVE_LOCK, 0, 1, 0, &lock_out);
+#else
+  int lockfd = open("rewrite-sym.lock", O_RDWR | O_CREAT, 0666);
+  while (flock(lockfd, LOCK_EX)) {  // :D

[dcheng, 2016/01/22 00:31:30]

Do we need to worry about contention here? Is there any fairness guarantee
around flock? I'm curious if how much this affects running time.

We could use named semaphores instead (sem_open/sem_wait/sem_post/sem_close),
right? Presumably, that has some guarantee of fairness and doesn't have a
spinloop like this.

If there's no real effect on running time, then I guess this is Good Enough.

[danakj, 2016/01/22 23:33:36]

I think it's okay, it takes like ~20min to run the tool over everything, but
each file's processing time is multiple seconds, the writing output is very tiny
compared to it. I didn't take measurements.. but it feels similar to before the
lock.

+  }
+#endif
+
   std::ofstream replacement_db_file("rewrite-sym.txt",
                                     std::ios_base::out | std::ios_base::app);
   for (const auto& p : field_decl_rewriter.replacement_names())
     replacement_db_file << "var:" << p.first << ":" << p.second << "\n";
   for (const auto& p : var_decl_rewriter.replacement_names())
     replacement_db_file << "var:" << p.first << ":" << p.second << "\n";
   for (const auto& p : function_decl_rewriter.replacement_names())
     replacement_db_file << "fun:" << p.first << ":" << p.second << "\n";
   for (const auto& p : method_decl_rewriter.replacement_names())
     replacement_db_file << "fun:" << p.first << ":" << p.second << "\n";
   replacement_db_file.close();
 
+#if defined(_WIN32)
+  UnlockFile(lockfd, 0, 0, 1, 0);
+  CloseHandle(lockfd);
+#else
+  flock(lockfd, LOCK_UN);
+  close(lockfd);
+#endif
+
   // Serialization format is documented in tools/clang/scripts/run_tool.py
   llvm::outs() << "==== BEGIN EDITS ====\n";
   for (const auto& r : replacements) {
     std::string replacement_text = r.getReplacementText().str();
     std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
     llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset()
                  << ":::" << r.getLength() << ":::" << replacement_text << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }