memdump 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb8daaffee80155c4227920118ed3793e3afe4ab
+  data.tar.gz: b57f30d96b9e35d8519d800cbca852ef6995d965
+SHA512:
+  metadata.gz: 84b9700c70b49d35b7c7910e1a047d4f1fd9aba7161888090bc3190e6e983a835b9417363376c3eabe648763eb537e57d89726440f9b8ac022b0920be60bd2fd
+  data.tar.gz: 206a0adbfd4c9f3b8d10f21c0ad07f911384977f79dee4a22e01af9c3710ab6e430e6f4ade72a37655e24eef2137025cec050dce232d2dacb0db75d1ae8f86e3

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in memdump.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sylvain Joyeux
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# Memdump
+
+Memdump is a set of (basic) tools to create and manipulate Ruby object dumps.
+
+Since Ruby 2.1, ObjectSpace can be dumped in a JSON file that represents all
+allocated objects and their relationships. It is a gold mine of information if
+you want to understand why your application has that many objects and/or a
+memory leak.
+
+Processing methods are available as a library, or using the `memdump`
+command-line tool. Just run `memdump help` for a summary of operations.
+
+**NOTE** running memdump under jruby really reduces processing times... If you're using rbenv, just do
+
+```
+rbenv shell jruby-9.0.5.0
+```
+
+in the shell where you run the memdump commands.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'memdump'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install memdump
+
+
+## Creating a memory dump
+
+### Using rbtrace
+
+The memdump command-line tool can connect to a process where
+the [excellent rbtrace](https://github.com/tmm1/rbtrace) has been required. Just
+start your Ruby application with `-r rbtrace`, e.g.
+
+```
+ruby -rrbtrace -S syskit run
+```
+
+and find out the process PID using e.g. top or ps (in the following, I assume
+that the PID is 1234)
+
+Memory dumps are then created with
+
+```
+memdump dump 1234 /tmp/mydump
+```
+
+Since `dump_all` requires very long, the rbtrace client will return before the
+end of the dump with `*** timed out waiting for eval response`. Check your
+application's output for a line saying `sendto(14): No such file or directory
+[detaching]`
+
+Additionally, you might want to enable allocation tracing, which adds to the
+dump the line/file of the point where the object got allocated but is also very
+costly from a performance point of view, do
+
+```
+memdump enable-allocation-trace 1234
+```
+
+### Manually
+
+It is sometimes more beneficial to do the dumps in specific places
+in your application, something the rbtrace method does not allow you to do. In
+this case, create memory dumps by calling `ObjectSpace.dump_all`
+
+~~~ ruby
+require 'objspace'
+File.open('/path/to/dump/file', 'w') do |io|
+  ObjectSpace.dump_all(output: io)
+end
+~~~
+
+Allocation tracing is enabled with
+
+~~~ ruby
+require 'objspace'
+ObjectSpace.trace_objects_allocation_start
+~~~
+
+## Analyzing the dump
+
+The first thing you will probably want to do is to run the replace-class command
+on the dump. It replaces the class attribute, which in the original dump is the
+reference to the class object, by the class name. This makes reading the dump a
+lot easier.
+
+```
+memdump replace-class /tmp/mydump
+```
+
+The most basic analysis is done by running **stats**, which outputs the object
+count by class. For memory leaks, the **diff** command allows you to output the
+part of the graph that involves new objects (removing the
+"old-and-not-referred-to-by-new")
+
+Beyond that, I usually go back and forth between the memory dump and
+[gephi](http://gephi.org), a graph analysis application. the **gml** command
+allows to convert the memory dump into a graph format that gephi can import.
+From there, use gephi's layouting and filtering algorithms to get an idea of the
+most likely objects. Then, you can "massage" the dump using the **root_of**,
+**subgraph_of** and **remove-node** commands to narrow the dump to its most useful
+parts.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/doudou/memdump.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/bin/memdump

@@ -0,0 +1,2 @@
+require 'memdump/cli'
+MemDump::CLI.start(ARGV)

data/lib/memdump.rb

@@ -0,0 +1,5 @@
+require "memdump/version"
+
+module Memdump
+  # Your code goes here...
+end

data/lib/memdump/cleanup_references.rb

@@ -0,0 +1,19 @@
+module MemDump
+    def self.cleanup_references(dump)
+        addresses = Set.new
+        records = Array.new
+        dump.each_record do |r|
+            addr = (r['address'] || r['root'])
+            addresses << addr
+            records << r
+        end
+
+        records.each do |r|
+            if references = r['references']
+                references.delete_if { |r| !addresses.include?(r) }
+            end
+        end
+        records
+    end
+end
+

data/lib/memdump/cli.rb

@@ -0,0 +1,134 @@
+require 'thor'
+require 'pathname'
+require 'memdump/json_dump'
+
+module MemDump
+    class CLI < Thor
+        desc 'enable-allocation-trace PID', 'enable the tracing of allocations on a running process'
+        def enable_allocation_trace(pid)
+            system('rbtrace', '-p', pid.to_s, '-e', "require \"objspace\"; ObjectSpace.trace_object_allocations_start")
+        end
+
+        desc 'dump PID FILE', 'generate a dump file from a running process'
+        def dump(pid, file)
+            file = File.expand_path(file)
+            system('rbtrace', '-p', pid.to_s, '-e', "require \"objspace\"; File.open(\"#{file}\", 'w') { |io| ObjectSpace.dump_all(output: io) }")
+        end
+
+        desc 'diff SOURCE TARGET OUTPUT', 'generate a memory dump that contains the objects in TARGET not in SOURCE, and all their parents'
+        def diff(source, target, output)
+            require 'memdump/diff'
+
+            STDOUT.sync = true
+            from = MemDump::JSONDump.new(Pathname.new(source))
+            to   = MemDump::JSONDump.new(Pathname.new(target))
+            records = MemDump.diff(from, to)
+            File.open(output, 'w') do |io|
+                records.each do |r|
+                    io.puts JSON.dump(r)
+                end
+            end
+        end
+
+        desc 'gml DUMP GML', 'converts a memory dump into a graph in the GML format (for processing by e.g. gephi)'
+        def gml(dump_path, gml_path = nil)
+            require 'memdump/convert_to_gml'
+
+            STDOUT.sync = true
+            dump_path = Pathname.new(dump_path)
+            if gml_path
+                gml_path = Pathname.new(gml_path)
+            else
+                gml_path = dump_path.sub_ext('.gml')
+            end
+
+            dump = MemDump::JSONDump.new(dump_path)
+            gml_path.open('w') do |io|
+                MemDump.convert_to_gml(dump, io)
+            end
+        end
+
+        desc "subgraph_of DUMP ADDRESS", "traces all objects that are reachable from the given object"
+        option :max_depth, desc: 'depth of the subgraph to generate', type: :numeric, default: Float::INFINITY
+        def subgraph_of(dump, address)
+            require 'memdump/subgraph_of'
+
+            STDOUT.sync = true
+            dump = MemDump::JSONDump.new(Pathname.new(dump))
+            MemDump.subgraph_of(dump, address, max_depth: options[:max_depth]).each do |r|
+                puts JSON.dump(r)
+            end
+        end
+
+        desc "root_of DUMP ADDRESS", "traces the object with the given address to the root that's holding it alive"
+        def root_of(dump, address)
+            require 'memdump/root_of'
+
+            STDOUT.sync = true
+            dump = MemDump::JSONDump.new(Pathname.new(dump))
+            MemDump.root_of(dump, address).each do |r|
+                puts JSON.dump(r)
+            end
+        end
+
+        desc 'replace-class DUMP OUTPUT', 'replaces the class address by the class name'
+        option :add_ref, desc: 'whether a reference to the class object should be added', type: :boolean, default: false
+        def replace_class(dump_path, output_path = nil)
+            require 'memdump/replace_class_address_by_name'
+
+            STDOUT.sync = true
+            dump_path = Pathname.new(dump_path)
+            output_path =
+                if output_path then Pathname.new(output_path)
+                else dump_path
+                end
+            dump = MemDump::JSONDump.new(dump_path)
+            result = MemDump.replace_class_address_by_name(dump, add_reference_to_class: options[:add_ref])
+            output_path.open('w') do |io|
+                result.each do |r|
+                    io.puts JSON.dump(r)
+                end
+            end
+        end
+
+        desc 'cleanup-refs DUMP OUTPUT', "removes references to deleted objects"
+        def cleanup_refs(dump, output)
+            require 'memdump/cleanup_references'
+
+            STDOUT.sync = true
+            dump = MemDump::JSONDump.new(Pathname.new(dump))
+            cleaned = MemDump.cleanup_references(dump)
+            Pathname.new(output).open('w') do |io|
+                cleaned.each do |r|
+                    io.puts JSON.dump(r)
+                end
+            end
+        end
+
+        desc 'remove-node DUMP NODE', 'remove all objects that are kept alive by the given node'
+        def remove_node(dump, node_id)
+            require 'memdump/remove_node'
+
+            STDOUT.sync = true
+            dump = MemDump::JSONDump.new(Pathname.new(dump))
+            cleaned = MemDump.remove_node(dump, node_id)
+            cleaned.each do |r|
+                STDOUT.puts JSON.dump(r)
+            end
+        end
+
+        desc 'stats DUMP', 'give statistics on the objects present in the dump'
+        def stats(dump)
+            require 'pp'
+            require 'memdump/stats'
+            dump = MemDump::JSONDump.new(Pathname.new(dump))
+            unknown, by_type = MemDump.stats(dump)
+            puts "#{unknown} objects without a known type"
+            by_type.sort_by { |n, v| v }.reverse.each do |n, v|
+                puts "#{n}: #{v}"
+            end
+        end
+    end
+end
+
+

data/lib/memdump/convert_to_gml.rb

@@ -0,0 +1,47 @@
+require 'set'
+
+module MemDump
+    def self.convert_to_gml(dump, io)
+        nodes = dump.each_record.map do |row|
+            if row['class_address'] # transformed with replace_class_address_by_name
+                name    = row['class']
+            else
+                name    = row['struct'] || row['root'] || row['type']
+            end
+
+            address = row['address'] || row['root']
+            refs = Hash.new
+            if row_refs = row['references']
+                row_refs.each { |r| refs[r] = nil }
+            end
+
+            [address, refs, name]
+        end
+
+        io.puts "graph"
+        io.puts "["
+        known_addresses = Set.new
+        nodes.each do |address, refs, name|
+            known_addresses << address
+            io.puts "  node"
+            io.puts "  ["
+            io.puts "    id #{address}"
+            io.puts "    label \"#{name}\""
+            io.puts "  ]"
+        end
+
+        nodes.each do |address, refs, _|
+            refs.each do |ref_address, ref_label|
+                io.puts "  edge"
+                io.puts "  ["
+                io.puts "    source #{address}"
+                io.puts "    target #{ref_address}"
+                if ref_label
+                    io.puts "    label \"#{ref_label}\""
+                end
+                io.puts "  ]"
+            end
+        end
+        io.puts "]"
+    end
+end

data/lib/memdump/diff.rb

@@ -0,0 +1,44 @@
+require 'set'
+
+module MemDump
+    def self.diff(from, to)
+        from_objects = Set.new
+        from.each_record { |r| from_objects << (r['address'] || r['root']) }
+        puts "#{from_objects.size} objects found in source dump"
+
+        selected_records = Hash.new
+        remaining_records = Array.new
+        to.each_record do |r|
+            address = (r['address'] || r['root'])
+            if !from_objects.include?(address)
+                selected_records[address] = r
+                r['only_in_target'] = 1
+            else
+                remaining_records << r
+            end
+        end
+
+        total = remaining_records.size + selected_records.size
+        count = 0
+        while selected_records.size != count
+            count = selected_records.size
+            puts "#{count}/#{total} records selected so far"
+            remaining_records.delete_if do |r|
+                address = (r['address'] || r['root'])
+                references = r['references']
+
+                if references && references.any? { |r| selected_records.has_key?(r) }
+                    selected_records[address] = r
+                end
+            end
+        end
+        puts "#{count}/#{total} records selected"
+
+        selected_records.each_value do |r|
+            if references = r['references']
+                references.delete_if { |a| !selected_records.has_key?(a) }
+            end
+        end
+        selected_records.each_value
+    end
+end

data/lib/memdump/json_dump.rb

@@ -0,0 +1,23 @@
+require 'json'
+module MemDump
+    class JSONDump
+        def initialize(filename)
+            @filename = filename
+        end
+
+        def each_record
+            return enum_for(__method__) if !block_given?
+
+            if @cached_entries
+                @cached_entries.each(&proc)
+            else
+                @filename.open do |f|
+                    f.each_line do |line|
+                        yield JSON.parse(line)
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/memdump/remove_node.rb

@@ -0,0 +1,43 @@
+module MemDump
+    def self.remove_node(dump, removed_node)
+        remaining_records = Hash.new
+        non_roots = Set.new
+        dump.each_record do |r|
+            address = (r['address'] || r['root'])
+            remaining_records[address] = r
+
+            if refs = r['references']
+                refs.each do |ref_address|
+                    non_roots << ref_address
+                end
+            end
+        end
+
+        roots = remaining_records.each_key.
+            find_all { |a| !non_roots.include?(a) }
+
+        queue = roots.dup
+        selected_records = Hash.new
+        while !queue.empty?
+            address = queue.shift
+            next if address == removed_node
+
+            if record = remaining_records.delete(address)
+                selected_records[address] = record
+                if refs = record['references']
+                    refs.each do |ref_address|
+                        queue << ref_address
+                    end
+                end
+            end
+        end
+
+        selected_records.values.reverse.map do |r|
+            if refs = r['references']
+                refs.delete_if { |a| !selected_records.has_key?(a) }
+            end
+            r
+        end
+    end
+end
+

data/lib/memdump/replace_class_address_by_name.rb

@@ -0,0 +1,25 @@
+module MemDump
+    # Replace the address in the 'class' attribute by the class name
+    def self.replace_class_address_by_name(dump, add_reference_to_class: false)
+        class_names = Hash.new
+        dump.each_record do |row|
+            if row['type'] == 'CLASS' || row['type'] == 'MODULE'
+                class_names[row['address']] = row['name']
+            end
+        end
+
+        dump.each_record.map do |r|
+            if klass = r['class']
+                r['class'] = class_names[klass] || klass
+                r['class_address'] = klass
+                if add_reference_to_class
+                    (r['references'] ||= Array.new) << klass
+                end
+            end
+            if r['type'] == 'ICLASS'
+                r['class'] = "I(#{r['class']})"
+            end
+            r
+        end
+    end
+end

data/lib/memdump/root_of.rb

@@ -0,0 +1,35 @@
+module MemDump
+    def self.root_of(dump, root_address)
+        remaining_records = Array.new
+        selected_records = Hash.new
+        selected_root = root_address
+        dump.each_record do |r|
+            address = (r['address'] || r['root'])
+            if selected_root == address
+                selected_records[address] = r
+                selected_root = nil;
+            else
+                remaining_records << r
+            end
+        end
+
+        count = 0
+        while count != selected_records.size
+            count = selected_records.size
+            remaining_records.delete_if do |r|
+                references = r['references']
+                if references && references.any? { |a| selected_records.has_key?(a) }
+                    address = (r['address'] || r['root'])
+                    selected_records[address] = r
+                end
+            end
+        end
+
+        selected_records.values.reverse.each do |r|
+            if refs = r['references']
+                refs.delete_if { |a| !selected_records.has_key?(a) }
+            end
+        end
+    end
+end
+

data/lib/memdump/stats.rb

@@ -0,0 +1,15 @@
+module MemDump
+    def self.stats(memdump)
+        unknown_class = 0
+        by_class = Hash.new(0)
+        memdump.each_record do |r|
+            if klass = (r['class'] || r['type'] || r['root'])
+                by_class[klass] += 1
+            else
+                unknown_class += 1
+            end
+        end
+        return unknown_class, by_class
+    end
+end
+

data/lib/memdump/subgraph_of.rb

@@ -0,0 +1,26 @@
+module MemDump
+    def self.subgraph_of(dump, root_address, max_depth: Float::INFINITY)
+        remaining_records = Hash.new
+        dump.each_record do |r|
+            address = (r['address'] || r['root'])
+            remaining_records[address] = r
+        end
+
+        selected_records = Hash.new
+        queue = [[root_address, 0]]
+        while !queue.empty?
+            address, depth = queue.shift
+            if record = remaining_records.delete(address)
+                selected_records[address] = record
+                if (depth < max_depth) && (refs = record['references'])
+                    refs.each do |ref_address|
+                        queue << [ref_address, depth + 1]
+                    end
+                end
+            end
+        end
+
+        selected_records.values
+    end
+end
+

data/lib/memdump/version.rb

@@ -0,0 +1,3 @@
+module Memdump
+    VERSION = "0.1.0"
+end

data/memdump.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memdump/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "memdump"
+  spec.version       = Memdump::VERSION
+  spec.authors       = ["Sylvain Joyeux"]
+  spec.email         = ["sylvain.joyeux@m4x.org"]
+
+  spec.summary       = %q{Tools to manipulate Ruby 2.1+ memory dumps}
+  spec.description   = %q{}
+  spec.homepage      = "https://github.com/doudou/memdump"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'thor'
+  spec.add_dependency 'rbtrace'
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: memdump
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sylvain Joyeux
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rbtrace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: ''
+email:
+- sylvain.joyeux@m4x.org
+executables:
+- memdump
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/memdump
+- lib/memdump.rb
+- lib/memdump/cleanup_references.rb
+- lib/memdump/cli.rb
+- lib/memdump/convert_to_gml.rb
+- lib/memdump/diff.rb
+- lib/memdump/json_dump.rb
+- lib/memdump/remove_node.rb
+- lib/memdump/replace_class_address_by_name.rb
+- lib/memdump/root_of.rb
+- lib/memdump/stats.rb
+- lib/memdump/subgraph_of.rb
+- lib/memdump/version.rb
+- memdump.gemspec
+homepage: https://github.com/doudou/memdump
+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.2.3
+signing_key: 
+specification_version: 4
+summary: Tools to manipulate Ruby 2.1+ memory dumps
+test_files: []
+has_rdoc: