Efficace Ruby cache LRU

Quel est le moyen le plus efficace pour construire un cache arbitraire Ruby objets comme des clés qui sont périmés basé sur un moins récemment utilisé l'algorithme. Utiliser Ruby est normal de hachage sémantique (et non l'égalité?)

  • Cherchez-vous pour un minimum de l'utilisation de la mémoire ou à peu de l'utilisation de l'uc, à quelle fréquence êtes-vous tomber des choses de la LRU cache? Vous pouvez soit aller au trésor approche ou d'une double liste chaînée avec une paire de hachage.
  • pour quelques idées, voir: java.sun.com/j2se/1.4.2/docs/api/java/util/LinkedHashMap.html aussi, mongodb a plafonné collection de même, vous pouvez faire ce genre de choses avec le redis. en supposant que vous êtes à la recherche pour un construit en ruby solution si
InformationsquelleAutor Yehuda Katz | 2009-12-19
  1. 10

    Cette repousse les limites de ma compréhension de la façon dont Ruby utilise de la mémoire, mais je pense que le plus efficace la mise en œuvre serait un doublement lié à la liste où tous les accès se déplace de la clé à l'avant de la liste, et chaque insertion des gouttes d'un élément, si la taille maximale a été atteinte.

    Cependant, en supposant que Ruby Hash classe est déjà très efficace, je serais prêt à parier que le un peu naïf solution simplement en ajoutant de l'âge de données à un Hash devrait être assez bonne. Voici un petit exemple jouet qui fait cela:

    class Cache
  attr_accessor :max_size

  def initialize(max_size = 4)
    @data = {}
    @max_size = max_size
  end

  def store(key, value)
    @data.store key, [0, value]
    age_keys
    prune
  end

  def read(key)
    if value = @data[key]
      renew(key)
      age_keys
    end
    value
  end

  private # -------------------------------

  def renew(key)
    @data[key][0] = 0
  end

  def delete_oldest
    m = @data.values.map{ |v| v[0] }.max
    @data.reject!{ |k,v| v[0] == m }
  end

  def age_keys
    @data.each{ |k,v| @data[k][0] += 1 }
  end

  def prune
    delete_oldest if @data.size > @max_size
  end
end

    Il y a probablement un moyen plus rapide de trouver l'élément le plus ancien, et ce n'est pas testés, mais je serais curieux de savoir comment quelqu'un pense que cela se compare à une structure plus sophistiquée, liste liée ou autrement.

    • delete_oldest est O(n), qui est inefficace, vous pouvez le faire en temps constant si vous utilisez une autre application
    InformationsquelleAutor Alex Reisner
  2. 27

    Je sais que ses quelques années de retard, mais j'ai juste mis ce que je crois est le plus rapide de la LRU Cache là-bas pour Ruby.

    Il est également testé et éventuellement de sécurité à utiliser en multi threaded environnements.

    https://github.com/SamSaffron/lru_redux

    Remarque: en Ruby 1.9 Hachage est ordonnée, de sorte que vous pouvez tricher et de construire le plus rapide LRU cache en quelques lignes de code

    class LruRedux::Cache19

  def initialize(max_size)
    @max_size = max_size
    @data = {}
  end

  def max_size=(size)
    raise ArgumentError.new(:max_size) if @max_size < 1
    @max_size = size
    if @max_size < @data.size
      @data.keys[0..@max_size-@data.size].each do |k|
        @data.delete(k)
      end
    end
  end

  def [](key)
    found = true
    value = @data.delete(key){ found = false }
    if found
      @data[key] = value
    else
      nil
    end
  end

  def []=(key,val)
    @data.delete(key)
    @data[key] = val
    if @data.length > @max_size
      @data.delete(@data.first[0])
    end
    val
  end

  def each
    @data.reverse.each do |pair|
      yield pair
    end
  end

  # used further up the chain, non thread safe each
  alias_method :each_unsafe, :each

  def to_a
    @data.to_a.reverse
  end

  def delete(k)
    @data.delete(k)
  end

  def clear
    @data.clear
  end

  def count
    @data.count
  end

  # for cache validation only, ensures all is sound
  def valid?
    true
  end
end
    InformationsquelleAutor Sam Saffron
  3. 4

    Remaze a raisonnablement bien testé LRU Cache: Voir http://github.com/manveru/ramaze/blob/master/lib/ramaze/snippets/ramaze/lru_hash.rb

    Et il y a aussi le hashery gem par rubyworks qui devrait être plus efficace que la remaze l'un pour les grands caches.

    InformationsquelleAutor Sam Saffron
  4. 2

    Le rufus-lru gem est une autre option.

    Au lieu d'un comte, il garde simplement un tableau trié de touches de la plus ancienne à la plus récente

    InformationsquelleAutor James Healy
  5. 2

    J'ai jeté un nouveau joyau lrucache qui pourraient vous être utiles. Il peut être plus rapide qu'Alex l'approche des collections, avec un nombre important d'éléments.

    InformationsquelleAutor Chris
  6. 1

    Ruby Meilleures Pratiques blog a un post à ce sujet.

    InformationsquelleAutor khelll
  7. 1

    Très simple et rapide cache lru-je utiliser dans notre http backend https://github.com/grosser/i18n-backend-http/blob/master/lib/i18n/backend/http/lru_cache.rb

    • Ce lien est aujourd'hui brisé.
    InformationsquelleAutor grosser