lib-cache.h

Go to the documentation of this file.

// Copyright 2012 Cloudera Inc.
//
// 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.


#ifndef IMPALA_RUNTIME_LIB_CACHE_H
#define IMPALA_RUNTIME_LIB_CACHE_H

#include <string>
#include <boost/scoped_ptr.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <boost/thread/mutex.hpp>
#include "common/atomic.h"
#include "common/object-pool.h"
#include "common/status.h"

namespace impala {

class RuntimeState;

//
//
//
class LibCache {
 public:
  struct LibCacheEntry;

  enum LibType {
    TYPE_SO,      // Shared object
    TYPE_IR,      // IR intermediate
    TYPE_JAR,     // Java jar file. We don't care about the contents in the BE.
  };

  static LibCache* instance() { return LibCache::instance_.get(); }

  ~LibCache();

  static Status Init();

  Status GetLocalLibPath(const std::string& hdfs_lib_file, LibType type,
                         std::string* local_path);

  Status CheckSymbolExists(const std::string& hdfs_lib_file, LibType type,
      const std::string& symbol, bool quiet = false);

  //
  //
  Status GetSoFunctionPtr(const std::string& hdfs_lib_file, const std::string& symbol,
      void** fn_ptr, LibCacheEntry** entry, bool quiet = false);

  void SetNeedsRefresh(const std::string& hdfs_lib_file);

  void DecrementUseCount(LibCacheEntry* entry);

  void RemoveEntry(const std::string& hdfs_lib_file);

  void DropCache();

 private:
  static boost::scoped_ptr<LibCache> instance_;

  void* current_process_handle_;

  AtomicInt<int64_t> num_libs_copied_;

  boost::mutex lock_;

  typedef boost::unordered_map<std::string, LibCacheEntry*> LibMap;
  LibMap lib_cache_;

  LibCache();
  LibCache(LibCache const& l); // disable copy ctor
  LibCache& operator=(LibCache const& l); // disable assignment

  Status InitInternal();

  Status GetCacheEntry(const std::string& hdfs_lib_file, LibType type,
      boost::unique_lock<boost::mutex>* entry_lock, LibCacheEntry** entry);

  Status GetCacheEntryInternal(const std::string& hdfs_lib_file, LibType type,
      boost::unique_lock<boost::mutex>* entry_lock, LibCacheEntry** entry);

  std::string MakeLocalPath(const std::string& hdfs_path, const std::string& local_dir);

  void RemoveEntryInternal(const std::string& hdfs_lib_file,
                           const LibMap::iterator& entry_iterator);
};

}

#endif