| // Copyright (c) 2013 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. |
| |
| #include "tools/gn/input_file_manager.h" |
| |
| #include "base/bind.h" |
| #include "base/stl_util.h" |
| #include "tools/gn/filesystem_utils.h" |
| #include "tools/gn/parser.h" |
| #include "tools/gn/scheduler.h" |
| #include "tools/gn/scope_per_file_provider.h" |
| #include "tools/gn/tokenizer.h" |
| |
| namespace { |
| |
| void InvokeFileLoadCallback(const InputFileManager::FileLoadCallback& cb, |
| const ParseNode* node) { |
| cb.Run(node); |
| } |
| |
| } // namespace |
| |
| InputFileManager::InputFileData::InputFileData(const SourceFile& file_name) |
| : file(file_name), |
| loaded(false), |
| sync_invocation(false) { |
| } |
| |
| InputFileManager::InputFileData::~InputFileData() { |
| } |
| |
| InputFileManager::InputFileManager() { |
| } |
| |
| InputFileManager::~InputFileManager() { |
| // Should be single-threaded by now. |
| STLDeleteContainerPairSecondPointers(input_files_.begin(), |
| input_files_.end()); |
| } |
| |
| bool InputFileManager::AsyncLoadFile(const LocationRange& origin, |
| const BuildSettings* build_settings, |
| const SourceFile& file_name, |
| const FileLoadCallback& callback, |
| Err* err) { |
| // Try not to schedule callbacks while holding the lock. All cases that don't |
| // want to schedule should return early. Otherwise, this will be scheduled |
| // after we leave the lock. |
| base::Closure schedule_this; |
| { |
| base::AutoLock lock(lock_); |
| |
| InputFileMap::const_iterator found = input_files_.find(file_name); |
| if (found == input_files_.end()) { |
| // New file, schedule load. |
| InputFileData* data = new InputFileData(file_name); |
| data->scheduled_callbacks.push_back(callback); |
| input_files_[file_name] = data; |
| |
| schedule_this = base::Bind(&InputFileManager::BackgroundLoadFile, |
| this, |
| origin, |
| build_settings, |
| file_name, |
| &data->file); |
| } else { |
| InputFileData* data = found->second; |
| |
| // Prevent mixing async and sync loads. See SyncLoadFile for discussion. |
| if (data->sync_invocation) { |
| g_scheduler->FailWithError(Err( |
| origin, "Load type mismatch.", |
| "The file \"" + file_name.value() + "\" was previously loaded\n" |
| "synchronously (via an import) and now you're trying to load it " |
| "asynchronously\n(via a deps rule). This is a class 2 misdemeanor: " |
| "a single input file must\nbe loaded the same way each time to " |
| "avoid blowing my tiny, tiny mind.")); |
| return false; |
| } |
| |
| if (data->loaded) { |
| // Can just directly issue the callback on the background thread. |
| schedule_this = base::Bind(&InvokeFileLoadCallback, callback, |
| data->parsed_root.get()); |
| } else { |
| // Load is pending on this file, schedule the invoke. |
| data->scheduled_callbacks.push_back(callback); |
| return true; |
| } |
| } |
| } |
| g_scheduler->pool()->PostWorkerTaskWithShutdownBehavior( |
| FROM_HERE, schedule_this, |
| base::SequencedWorkerPool::BLOCK_SHUTDOWN); |
| return true; |
| } |
| |
| const ParseNode* InputFileManager::SyncLoadFile( |
| const LocationRange& origin, |
| const BuildSettings* build_settings, |
| const SourceFile& file_name, |
| Err* err) { |
| base::AutoLock lock(lock_); |
| |
| InputFileData* data = NULL; |
| InputFileMap::iterator found = input_files_.find(file_name); |
| if (found == input_files_.end()) { |
| base::AutoUnlock unlock(lock_); |
| |
| // Haven't seen this file yet, start loading right now. |
| data = new InputFileData(file_name); |
| data->sync_invocation = true; |
| input_files_[file_name] = data; |
| |
| if (!LoadFile(origin, build_settings, file_name, &data->file, err)) |
| return NULL; |
| } else { |
| // This file has either been loaded or is pending loading. |
| data = found->second; |
| |
| if (!data->sync_invocation) { |
| // Don't allow mixing of sync and async loads. If an async load is |
| // scheduled and then a bunch of threads need to load it synchronously |
| // and block on it loading, it could deadlock or at least cause a lot |
| // of wasted CPU while those threads wait for the load to complete (which |
| // may be far back in the input queue). |
| // |
| // We could work around this by promoting the load to a sync load. This |
| // requires a bunch of extra code to either check flags and likely do |
| // extra locking (bad) or to just do both types of load on the file and |
| // deal with the race condition. |
| // |
| // I have no practical way to test this, and generally we should have |
| // all include files processed synchronously and all build files |
| // processed asynchronously, so it doesn't happen in practice. |
| *err = Err( |
| origin, "Load type mismatch.", |
| "The file \"" + file_name.value() + "\" was previously loaded\n" |
| "asynchronously (via a deps rule) and now you're trying to load it " |
| "synchronously.\nThis is a class 2 misdemeanor: a single input file " |
| "must be loaded the same way\neach time to avoid blowing my tiny, " |
| "tiny mind."); |
| return NULL; |
| } |
| |
| if (!data->loaded) { |
| // Wait for the already-pending sync load to complete. |
| if (!data->completion_event) |
| data->completion_event.reset(new base::WaitableEvent(false, false)); |
| { |
| base::AutoUnlock unlock(lock_); |
| data->completion_event->Wait(); |
| } |
| } |
| } |
| |
| // The other load could have failed. In this case that error will be printed |
| // to the console, but we need to return something here, so make up a |
| // dummy error. |
| if (!data->parsed_root) |
| *err = Err(origin, "File parse failed"); |
| return data->parsed_root.get(); |
| } |
| |
| int InputFileManager::GetInputFileCount() const { |
| base::AutoLock lock(lock_); |
| return input_files_.size(); |
| } |
| |
| void InputFileManager::GetAllInputFileNames( |
| std::vector<SourceFile>* result) const { |
| base::AutoLock lock(lock_); |
| result->reserve(input_files_.size()); |
| for (InputFileMap::const_iterator i = input_files_.begin(); |
| i != input_files_.end(); ++i) { |
| result->push_back(i->second->file.name()); |
| } |
| } |
| |
| void InputFileManager::BackgroundLoadFile(const LocationRange& origin, |
| const BuildSettings* build_settings, |
| const SourceFile& name, |
| InputFile* file) { |
| Err err; |
| if (!LoadFile(origin, build_settings, name, file, &err)) |
| g_scheduler->FailWithError(err); |
| } |
| |
| bool InputFileManager::LoadFile(const LocationRange& origin, |
| const BuildSettings* build_settings, |
| const SourceFile& name, |
| InputFile* file, |
| Err* err) { |
| // Do all of this stuff outside the lock. We should not give out file |
| // pointers until the read is complete. |
| if (g_scheduler->verbose_logging()) |
| g_scheduler->Log("Loading", name.value()); |
| |
| // Read. |
| base::FilePath primary_path = build_settings->GetFullPath(name); |
| if (!file->Load(primary_path)) { |
| if (!build_settings->secondary_source_path().empty()) { |
| // Fall back to secondary source tree. |
| base::FilePath secondary_path = |
| build_settings->GetFullPathSecondary(name); |
| if (!file->Load(secondary_path)) { |
| *err = Err(origin, "Can't load input file.", |
| "Unable to load either \n" + |
| FilePathToUTF8(primary_path) + " or \n" + |
| FilePathToUTF8(secondary_path)); |
| return false; |
| } |
| } else { |
| *err = Err(origin, |
| "Unable to load \"" + FilePathToUTF8(primary_path) + "\"."); |
| return false; |
| } |
| } |
| |
| if (g_scheduler->verbose_logging()) |
| g_scheduler->Log("Parsing", name.value()); |
| |
| // Tokenize. |
| std::vector<Token> tokens = Tokenizer::Tokenize(file, err); |
| if (err->has_error()) |
| return false; |
| |
| // Parse. |
| scoped_ptr<ParseNode> root = Parser::Parse(tokens, err); |
| if (err->has_error()) |
| return false; |
| ParseNode* unowned_root = root.get(); |
| |
| std::vector<FileLoadCallback> callbacks; |
| { |
| base::AutoLock lock(lock_); |
| DCHECK(input_files_.find(name) != input_files_.end()); |
| |
| InputFileData* data = input_files_[name]; |
| data->loaded = true; |
| data->tokens.swap(tokens); |
| data->parsed_root = root.Pass(); |
| |
| callbacks.swap(data->scheduled_callbacks); |
| } |
| |
| // Run pending invocations. Theoretically we could schedule each of these |
| // separately to get some parallelism. But normally there will only be one |
| // item in the list, so that's extra overhead and complexity for no gain. |
| for (size_t i = 0; i < callbacks.size(); i++) |
| callbacks[i].Run(unowned_root); |
| return true; |
| } |