<?xml version="1.0" encoding="UTF-8"?>

<rdf:RDF 
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns="http://purl.org/rss/1.0/"
  xmlns:dc="http://purl.org/dc/elements/1.1/"
  xmlns:syn="http://purl.org/rss/1.0/modules/syndication/"
>

  <channel rdf:about="http://lwn.net/headlines/260068/">
    <title>LWN: Comments on "kmemcheck"</title>
    <link>http://lwn.net/Articles/260068/</link>
    <description>
This is a special feed containing comments posted
to the individual LWN article titled &quot;kmemcheck&quot;.

    </description>

    <syn:updatePeriod>hourly</syn:updatePeriod>
    <syn:updateFrequency>2</syn:updateFrequency>
    <items>
      <rdf:Seq>
	<rdf:li resource="http://lwn.net/Articles/260453/rss" />
	<rdf:li resource="http://lwn.net/Articles/260402/rss" />
	<rdf:li resource="http://lwn.net/Articles/260398/rss" />
	<rdf:li resource="http://lwn.net/Articles/260392/rss" />
	<rdf:li resource="http://lwn.net/Articles/260389/rss" />
	<rdf:li resource="http://lwn.net/Articles/260335/rss" />
	<rdf:li resource="http://lwn.net/Articles/260326/rss" />
	<rdf:li resource="http://lwn.net/Articles/260309/rss" />
      
      </rdf:Seq>
    </items>

  </channel>
    <item rdf:about="http://lwn.net/Articles/260453/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260453/rss</link>
      <dc:date>2007-11-30T02:18:05+00:00</dc:date>
      <dc:creator>vomlehn</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
I would say that this idea pretty much rocks. Yes, it will slow the kernel way down and that
will make it unusable for production use, but the ability to do these checks on debugging
kernels is an excellent idea and the implementation makes a lot of sense for a first cut.
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260402/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260402/rss</link>
      <dc:date>2007-11-29T19:06:18+00:00</dc:date>
      <dc:creator>nix</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
Also the extra memory accesses will tend to blow the cache more if you use 
more memory to track the uninit state.
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260398/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260398/rss</link>
      <dc:date>2007-11-29T18:52:21+00:00</dc:date>
      <dc:creator>felixfix</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
Well, hmmmm, I guess I was thinking just enough to stick my foot in my mouth :-)
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260392/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260392/rss</link>
      <dc:date>2007-11-29T18:41:38+00:00</dc:date>
      <dc:creator>lysse</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
When there's already a page fault happening on every memory access, I have some doubts of the
significance of such additional overhead.
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260389/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260389/rss</link>
      <dc:date>2007-11-29T18:16:17+00:00</dc:date>
      <dc:creator>felixfix</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
The code to map bits would be slower; maybe he did not like the tradeoff.
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260335/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260335/rss</link>
      <dc:date>2007-11-29T15:20:52+00:00</dc:date>
      <dc:creator>jreiser</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
On a 32-bit machine it is tempting to use 8 bits (an entire byte) to track access to 32 bits
(one word) of memory.  This gives speed while still saving some space.
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260326/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260326/rss</link>
      <dc:date>2007-11-29T14:44:04+00:00</dc:date>
      <dc:creator>nix</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
A bitmap definitely can be used instead. (This is how valgrind's memcheck 
tool implements uninitialized checks, although using JIT simulation rather 
than page faulting to detect accesses.)
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
    <item rdf:about="http://lwn.net/Articles/260309/rss">
      <title>kmemcheck</title>
      <link>http://lwn.net/Articles/260309/rss</link>
      <dc:date>2007-11-29T13:19:58+00:00</dc:date>
      <dc:creator>dw</dc:creator>
      <description>
      &lt;div class=&quot;FormattedComment&quot;&gt;&lt;pre&gt;
Doubling the size of every allocation seems pretty wasteful, couldn't a bitmap be used
instead, with byte or even word-level granularity?

new_size = (size + (size/8))
&lt;/pre&gt;&lt;/div&gt;

      
      </description>
    </item>
</rdf:RDF>

