| // Copyright 2008 Google Inc. All Rights Reserved. |
| |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Thread-safe container of disk blocks |
| |
| // This file must work with autoconf on its public version, |
| // so these includes are correct. |
| #include "disk_blocks.h" |
| |
| #include <utility> |
| |
| // BlockData |
| BlockData::BlockData() : address_(0), size_(0), |
| references_(0), initialized_(false), |
| pattern_(NULL) { |
| pthread_mutex_init(&data_mutex_, NULL); |
| } |
| |
| BlockData::~BlockData() { |
| pthread_mutex_destroy(&data_mutex_); |
| } |
| |
| void BlockData::set_initialized() { |
| pthread_mutex_lock(&data_mutex_); |
| initialized_ = true; |
| pthread_mutex_unlock(&data_mutex_); |
| } |
| |
| bool BlockData::initialized() const { |
| pthread_mutex_lock(&data_mutex_); |
| bool initialized = initialized_; |
| pthread_mutex_unlock(&data_mutex_); |
| return initialized; |
| } |
| |
| // DiskBlockTable |
| DiskBlockTable::DiskBlockTable() : sector_size_(0), write_block_size_(0), |
| device_name_(""), device_sectors_(0), |
| segment_size_(0), size_(0) { |
| pthread_mutex_init(&data_mutex_, NULL); |
| pthread_mutex_init(¶meter_mutex_, NULL); |
| pthread_cond_init(&data_condition_, NULL); |
| } |
| |
| DiskBlockTable::~DiskBlockTable() { |
| pthread_mutex_destroy(&data_mutex_); |
| pthread_mutex_destroy(¶meter_mutex_); |
| pthread_cond_destroy(&data_condition_); |
| } |
| |
| // 64-bit non-negative random number generator. Stolen from |
| // depot/google3/base/tracecontext_unittest.cc. |
| int64 DiskBlockTable::Random64() { |
| int64 x = random(); |
| x = (x << 30) ^ random(); |
| x = (x << 30) ^ random(); |
| if (x >= 0) |
| return x; |
| else |
| return -x; |
| } |
| |
| uint64 DiskBlockTable::Size() { |
| pthread_mutex_lock(&data_mutex_); |
| uint64 size = size_; |
| pthread_mutex_unlock(&data_mutex_); |
| return size; |
| } |
| |
| void DiskBlockTable::InsertOnStructure(BlockData *block) { |
| int64 address = block->address(); |
| StorageData *sd = new StorageData(); |
| sd->block = block; |
| sd->pos = size_; |
| // Creating new block ... |
| pthread_mutex_lock(&data_mutex_); |
| if (pos_to_addr_.size() <= size_) { |
| pos_to_addr_.insert(pos_to_addr_.end(), address); |
| } else { |
| pos_to_addr_[size_] = address; |
| } |
| addr_to_block_[address] = sd; |
| size_++; |
| pthread_cond_broadcast(&data_condition_); |
| pthread_mutex_unlock(&data_mutex_); |
| } |
| |
| int DiskBlockTable::RemoveBlock(BlockData *block) { |
| // For write threads, check the reference counter and remove |
| // it from the structure. |
| int64 address = block->address(); |
| AddrToBlockMap::iterator it = addr_to_block_.find(address); |
| int ret = 1; |
| if (it != addr_to_block_.end()) { |
| int curr_pos = it->second->pos; |
| int last_pos = size_ - 1; |
| AddrToBlockMap::iterator last_it = addr_to_block_.find( |
| pos_to_addr_[last_pos]); |
| sat_assert(size_ > 0); |
| sat_assert(last_it != addr_to_block_.end()); |
| // Everything is fine, removing block from table. |
| pthread_mutex_lock(&data_mutex_); |
| pos_to_addr_[curr_pos] = pos_to_addr_[last_pos]; |
| last_it->second->pos = curr_pos; |
| delete it->second; |
| addr_to_block_.erase(it); |
| size_--; |
| block->DecreaseReferenceCounter(); |
| if (block->GetReferenceCounter() == 0) |
| delete block; |
| else if (block->GetReferenceCounter() < 0) |
| ret = 0; |
| pthread_cond_broadcast(&data_condition_); |
| pthread_mutex_unlock(&data_mutex_); |
| } else { |
| ret = 0; |
| } |
| return ret; |
| } |
| |
| int DiskBlockTable::ReleaseBlock(BlockData *block) { |
| // If caller is a random thread, just check the reference counter. |
| int ret = 1; |
| pthread_mutex_lock(&data_mutex_); |
| int references = block->GetReferenceCounter(); |
| if (references == 1) |
| delete block; |
| else if (references > 0) |
| block->DecreaseReferenceCounter(); |
| else |
| ret = 0; |
| pthread_mutex_unlock(&data_mutex_); |
| return ret; |
| } |
| |
| BlockData *DiskBlockTable::GetRandomBlock() { |
| struct timespec ts; |
| struct timeval tp; |
| gettimeofday(&tp, NULL); |
| ts.tv_sec = tp.tv_sec; |
| ts.tv_nsec = tp.tv_usec * 1000; |
| ts.tv_sec += 2; // Wait for 2 seconds. |
| int result = 0; |
| pthread_mutex_lock(&data_mutex_); |
| while (!size_ && result != ETIMEDOUT) { |
| result = pthread_cond_timedwait(&data_condition_, &data_mutex_, &ts); |
| } |
| if (result == ETIMEDOUT) { |
| pthread_mutex_unlock(&data_mutex_); |
| return NULL; |
| } else { |
| int64 random_number = Random64(); |
| int64 random_pos = random_number % size_; |
| int64 address = pos_to_addr_[random_pos]; |
| AddrToBlockMap::const_iterator it = addr_to_block_.find(address); |
| sat_assert(it != addr_to_block_.end()); |
| BlockData *b = it->second->block; |
| // A block is returned only if its content is written on disk. |
| if (b->initialized()) { |
| b->IncreaseReferenceCounter(); |
| } else { |
| b = NULL; |
| } |
| pthread_mutex_unlock(&data_mutex_); |
| return b; |
| } |
| } |
| |
| void DiskBlockTable::SetParameters(int sector_size, |
| int write_block_size, |
| int64 device_sectors, |
| int64 segment_size, |
| const string& device_name) { |
| sat_assert(size_ == 0); |
| pthread_mutex_lock(¶meter_mutex_); |
| sector_size_ = sector_size; |
| write_block_size_ = write_block_size; |
| device_sectors_ = device_sectors; |
| segment_size_ = segment_size; |
| device_name_ = device_name; |
| pthread_mutex_unlock(¶meter_mutex_); |
| } |
| |
| BlockData *DiskBlockTable::GetUnusedBlock(int64 segment) { |
| int64 sector = 0; |
| BlockData *block = new BlockData(); |
| bool good_sequence = false; |
| if (block == NULL) { |
| logprintf(0, "Process Error: Unable to allocate memory " |
| "for sector data for disk %s.\n", device_name_.c_str()); |
| return NULL; |
| } |
| pthread_mutex_lock(¶meter_mutex_); |
| sat_assert(device_sectors_ != 0); |
| // Align the first sector with the beginning of a write block |
| int num_sectors = write_block_size_ / sector_size_; |
| for (int i = 0; i < kBlockRetry && !good_sequence; i++) { |
| good_sequence = true; |
| // Use the entire disk or a small segment of the disk to allocate the first |
| // sector in the block from. |
| if (segment_size_ == -1) { |
| sector = (Random64() & 0x7FFFFFFFFFFFFFFFLL) % ( |
| device_sectors_ / num_sectors); |
| sector *= num_sectors; |
| } else { |
| sector = (Random64() & 0x7FFFFFFFFFFFFFFFLL) % ( |
| segment_size_ / num_sectors); |
| sector *= num_sectors; |
| sector += segment * segment_size_; |
| // Make sure the block is within the segment. |
| if (sector + num_sectors > (segment + 1) * segment_size_) { |
| good_sequence = false; |
| continue; |
| } |
| } |
| // Make sure the entire block is in range. |
| if (sector + num_sectors > device_sectors_) { |
| good_sequence = false; |
| continue; |
| } |
| // Check to see if the block is free. Since the blocks are |
| // now aligned to the write_block_size, it is not necessary |
| // to check each sector, just the first block (a sector |
| // overlap will never occur). |
| pthread_mutex_lock(&data_mutex_); |
| if (addr_to_block_.find(sector) != addr_to_block_.end()) { |
| good_sequence = false; |
| } |
| pthread_mutex_unlock(&data_mutex_); |
| } |
| |
| if (good_sequence) { |
| block->set_address(sector); |
| block->set_size(write_block_size_); |
| block->IncreaseReferenceCounter(); |
| InsertOnStructure(block); |
| } else { |
| // No contiguous sequence of num_sectors sectors was found within |
| // kBlockRetry iterations so return an error value. |
| delete block; |
| block = NULL; |
| } |
| pthread_mutex_unlock(¶meter_mutex_); |
| return block; |
| } |