ttd_set_associative_cache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 06a69ab6fc0062a060c62e6dc201d85b2eabb429
+  data.tar.gz: 1f48e20862824159ef183c741e1c85a6526fbd84
+SHA512:
+  metadata.gz: f1fd7b3dc2ce886089797491c9fbce750e2af2a89e88fc3dc27ccf0e51431aa1a71ae596ed1fd5ba20e02809d683c82cfd50cc57e42f8b8dd90f6fd42b8b4117
+  data.tar.gz: 4809aeb717f20502a92992f017b7c2d3cf52cd37c20115cf40944b133e78ea5516ccd47e232384e0b5362597b83f2ec776af9c5759feef37587d6caa65d93226

data/lib/hash_map.rb

@@ -0,0 +1,42 @@
+class HashMap
+  def initialize(&key_generator_prc)
+    key_generator_prc ||= Proc.new { |val| val.hash }
+    @cache = {}
+    @key_generator_prc = key_generator_prc
+  end
+
+  def create_key(val)
+    @key_generator_prc.call(val)
+  end
+
+  def add(val)
+    key = create_key(val)
+    @cache[key] = val
+  end
+
+  def remove(val)
+    key = create_key(val)
+    @cache.delete(key)
+  end
+
+  def update(val)
+    add(val)
+  end
+
+  def include?(val)
+    key = create_key(val)
+    @cache.include?(key)
+  end
+
+  def [](key)
+    @cache[key]
+  end
+
+  def length
+    @cache.length
+  end
+
+  def each
+    @cache.each { |key, value| yield key, value }
+  end
+end

data/lib/linked_list.rb

@@ -0,0 +1,119 @@
+require_relative './linked_list.rb'
+
+class LinkedList
+  attr_reader :length
+
+  def initialize
+    @head = LinkedListNode.new
+    @tail = LinkedListNode.new
+    @head.next = @tail
+    @tail.prev = @head
+
+    @length = 0
+  end
+
+  def first
+    @head.next == @tail ? nil : @head.next
+  end
+
+  def last
+    @tail.prev == @head ? nil : @tail.prev
+  end
+
+  def append(value)
+    node = value.class == LinkedListNode ? value : LinkedListNode.new(value)
+
+    old_last = @tail.prev
+    old_last.next = node
+    @tail.prev = node
+    node.prev = old_last
+    node.next = @tail
+
+    @length += 1
+    node
+  end
+
+  def prepend(value)
+    node = value.class == LinkedListNode ? value : LinkedListNode.new(value)
+
+    old_first = @head.next
+    old_first.prev = node
+    @head.next = node
+    node.next = old_first
+    node.prev = @head
+
+    @length += 1
+    node
+  end
+
+  def pop
+    return nil if @head.next == @tail
+    remove(@tail.prev)
+  end
+
+  def shift
+    return nil if @head.next == @tail
+    remove(@head.next)
+  end
+
+  def remove(node)
+    raise "Error in LinkedList#remove - given node is not a LinkedListNode, class is #{node.class}" unless node.class == LinkedListNode
+    return if node == @tail || node == @head
+
+    node.prev.next = node.next
+    node.next.prev = node.prev
+    node.prev = nil
+    node.next = nil
+    @length -= 1
+
+    node
+  end
+
+  def each
+    current = @head.next
+
+    until current == @tail do
+      yield current
+      current = current.next
+    end
+  end
+
+  def each_with_index
+    current = @head.next
+    counter = 0
+
+    until current == @tail do
+      yield current, counter
+      current = current.next
+      counter += 1
+    end
+  end
+
+  def map(&prc)
+    prc ||= Proc.new { |node| node }
+    current = @head.next
+    result = []
+
+    until current == @tail do
+      result << prc.call(current)
+      current = current.next
+    end
+
+    result
+  end
+
+  def map_with_index(&prc)
+    prc ||= Proc.new { |node, idx| node }
+    current = @head.next
+    counter = 0
+    result = []
+
+    until current == @tail do
+      result << prc.call(current, counter)
+      current = current.next
+      counter += 1
+    end
+
+    result
+  end
+end

data/lib/linked_list_node.rb

@@ -0,0 +1,28 @@
+class LinkedListNode
+  attr_reader :prev, :next
+  attr_accessor :value
+
+  def initialize(value = nil)
+    raise "Error in LinkedListNode::new - value is a LinkedListNode instance" if value.class == LinkedListNode
+
+    @value = value
+    @prev = nil
+    @next = nil
+  end
+
+  def prev=(other_node)
+    _validate_node(other_node, :prev)
+    @prev = other_node
+  end
+
+  def next=(other_node)
+    _validate_node(other_node, :next)
+    @next = other_node
+  end
+
+  private
+
+  def _validate_node(node, function_name)
+    raise "Error in LinkedListNode##{function_name} - other_node is not a LinkedListNode instance" unless node.class == LinkedListNode || node.nil?
+  end
+end

data/lib/set_associative_cache.rb

@@ -0,0 +1,129 @@
+require_relative './linked_list_node.rb'
+require_relative './linked_list.rb'
+require_relative './hash_map.rb'
+require 'byebug'
+
+class SetAssociativeCache
+  @@lru_replacement_proc = Proc.new { removed_node = @linked_list.pop; @hash_map.remove(removed_node) }
+  @@mru_replacement_proc = Proc.new { @linked_list.remove(@last_addition); @hash_map.remove(@last_addition) }
+
+  @@param_types = {
+    type: Symbol,
+    capacity: Fixnum,
+    key_generator_prc: Proc,
+    replacement_algo: Proc,
+    value_class: Class
+  }
+
+  def initialize(params = {})
+    _validate_params(params)
+
+    @hash_map = _initialize_hash_map(params)
+    @linked_list = LinkedList.new
+    @cache_type = params[:type] || :LRU
+    @replacement_algo = params[:replacement_algo] || _select_replacement_algo
+    @capacity = _initialize_capacity(params)
+    @value_class = params[:value_class]
+  end
+
+  # Handles adding new values and updating existing values.
+  def add(value)
+    search_node = value.class == LinkedListNode ? value : LinkedListNode.new(value)
+    @value_class ||= search_node.value.class
+
+    raise "Error in SetAssociativeCache#add - value class '#{value.class}' should be '#{@value_class}'" \
+      unless search_node.value.class == @value_class
+    key = @hash_map.create_key(search_node)
+    node = @hash_map[key]
+
+    if node
+      # update value if needed (ex. if a part of the value was updated but the key stayed the same)
+      node.value = value;
+
+      @linked_list.remove(node)
+    else
+      node = LinkedListNode.new(value)
+      @hash_map.add(node)
+      instance_exec([], &@replacement_algo) if @hash_map.length > @capacity
+    end
+
+    @linked_list.prepend(node)
+    @last_addition = node
+
+    node
+  end
+
+  # Finds the node whose value matches a the corresponding key if it exists.
+  def get_node(value)
+    node = value.class == LinkedListNode ? value : LinkedListNode.new(value)
+    key = @hash_map.create_key(node)
+    @hash_map[key]
+  end
+
+  # Loops over the nodes from head to tail in the linked list
+  def each
+    @linked_list.each { |node| yield node }
+  end
+
+  # Returns the number of values in the cache
+  def length
+    @hash_map.length
+  end
+
+  # Returns the newest / most recent node in the cache
+  def first
+    @linked_list.first
+  end
+
+  # Returns the oldest / least recent node in the cache
+  def last
+    @linked_list.last
+  end
+
+  def include?(value)
+    get_node(value) ? true : false
+  end
+
+  private
+
+  def _validate_params(params)
+    raise "Error in SetAssociativeCache#initialize - params input should be a hash" unless params.class == Hash
+    raise "Error in SetAssociativeCache#initialize - params keys should all be symbols" unless params.all? { |key, _| key.class == Symbol }
+
+    params.each do |key, val|
+      raise "Error in SetAssociativeCache#initialize - Unrecognized param '#{key}'" unless @@param_types.has_key?(key)
+      raise "Error in SetAssociativeCache#initialize - Invalid type for params[:#{key}], expected #{@@param_types[key]}, got #{val.class}" \
+        unless @@param_types[key] == val.class
+    end
+  end
+
+  def _initialize_hash_map(params)
+    if params[:key_generator_prc]
+      raise "Error invalid type for :key_generator_prc, expected Proc, got '#{params[:key_generator_prc].class}'" unless params[:key_generator_prc].class == Proc
+      key_generator_prc = Proc.new { |node| params[:key_generator_prc].call(node.value).hash }
+    else HashMap.new
+      key_generator_prc = Proc.new { |node| node.value.hash }
+    end
+
+    HashMap.new(&key_generator_prc)
+  end
+
+  def _select_replacement_algo
+    if @cache_type == :LRU
+      return @@lru_replacement_proc
+    elsif @cache_type == :MRU
+      return @@mru_replacement_proc
+    else
+      raise "Unrecognized cache :type provided '#{@cache_type}' and no :replacement_algo was given"
+    end
+  end
+
+  def _initialize_capacity(params)
+    if params[:capacity]
+      raise "Error in SetAssociativeCache#initialize - :capacity must be at least 4" unless params[:capacity] >= 4
+      return params[:capacity]
+    end
+
+    Float::INFINITY
+  end
+end

data/lib/ttd_set_associative_cache.rb

@@ -0,0 +1 @@
+require_relative './set_associative_cache.rb'

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: ttd_set_associative_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Travis Ludlum
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-17 00:00:00.000000000 Z
+dependencies: []
+description: A set associative cache
+email: nequalszero@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hash_map.rb
+- lib/linked_list.rb
+- lib/linked_list_node.rb
+- lib/set_associative_cache.rb
+- lib/ttd_set_associative_cache.rb
+homepage: http://rubygems.org/gems/ttd_set_associative_cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: set associative cache
+test_files: []