Are segments so bad?

By: Anne O. Nymous (not.delete@this.real.address), January 13, 2020 1:22 pm
Room: Moderated Discussions
Brendan (btrotter.delete@this.gmail.com) on January 13, 2020 12:02 pm wrote:
> Hi,
>
> Jukka Larja (roskakori2006.delete@this.gmail.com) on January 13, 2020 8:43 am wrote:
> > Brendan (btrotter.delete@this.gmail.com) on January 13, 2020 7:21 am wrote:
> > > Jukka Larja (roskakori2006.delete@this.gmail.com) on January 13, 2020 6:41 am wrote:
> > > > Brendan (btrotter.delete@this.gmail.com) on January 12, 2020 9:19 pm wrote:
> > > > > anon (anon.delete@this.b.c) on January 12, 2020 11:30 am wrote:
> > > > > >
> > > > > > Even if you write your own code extremely carefully, unless you a programming in an embedded context
> > > > > > where you wrote all the code running on the platform, you can be pretty damn certain there is a
> > > > > > lot of other parts in your system that are not able to gracefully handle OOM. There are just no
> > > > > > server or desktop platforms in widespread use that can deal with OOM. It's entirely possible that
> > > > > > your program sucks up all the memory, and then OOM is triggered by some crucial background service
> > > > > > that nothing can live without, and which does not have viable alternatives to allocating.
> > > > > >
> > > > > > It's because of this that the sane option for desktop or server is to just ignore OOM and
> > > > > > pretend it doesn't exist. Just hardening your own software is the worst kind of idiocy
> > > > > > -- it's a massive waste of time, and it doesn't actually protect you from anything.
> > > > >
> > > > > This kind of thinking is the reason why the world sucks ("Some software is shit, therefore all software
> > > > > should be forced to be shit forever and nobody should ever try to make software better").
> > > >
> > > > This assumes there's an easy way to "make software better". Sure, if during large parallel
> > > > compile system runs out of memory, the compile can be restarted with less parallelism. And
> > > > when our custom game asset builder runs out of memory, just restart from some previous known
> > > > good state. Oh wait, that already happens when we just hit "Build" button again (or someone
> > > > makes an SVN commit and build system automatically start making a new build).
> > > >
> > > > OOMs are practically never a problem for us. Running with not-quite-enough-physical-memory is sometimes
> > > > a problem, but gets handled nicely by virtual memory. On average, we have plenty of RAM. Sometimes
> > > > various independent processes with large memory footprint just happen to run at the same time.
> > > >
> > > > If I had to come up with some manual system to handle the problem, I don't really see what I could
> > > > do to improve it. There could be some heuristics about available memory that would affect how much
> > > > parallel processes are launched. The problem is coming up with good heuristics. I have no idea how
> > > > much the shader compiler will need this time, or if it needs to run at all. There's hundreds of variables
> > > > to consider, each only making sense to couple of programmers in our thirty-ish member team.
> > > >
> > > > Virtual memory is by no means necessary to solve this problem easily. We have build
> > > > servers mostly configured with static page files, so as long as it is possible to
> > > > just add equivalent amount of RAM, the OOM problem will be solved just as well.
> > >
> > > Maybe the only thing you're thinking about is your build system,
> > > and the only people that care about your build system is you?
> > >
> > > Consider a HTTP server - do you want to (e.g.) drop one connection or abort
> > > one request, or do you want to get killed and drop all current connections?
> > >
> > > Consider a word processor - do you want to (e.g.) free memory from the "undo buffer" and retry
> > > (and if that doesn't work display a dialog box informing the user and save the current document
> > > and shut down gracefully); or do you want to get killed and lose all the user's unsaved work;
> > > or do you want kill X11 and screw up every single app that's currently running?
> > >
> > > How about a database management engine with 8 GiB of cached data it can easily discard - would you
> > > want everything that depends on it to suffer "sudden database un-availability" for no reason?
> >
> > In my mind, it is "do I want those developers to fix some other bugs or spent
> > their time on already well handled OOM problem?"
>
> My perspective is more like; do I trust software written by people that are so incompetent they don't care if
> it randomly "crashes" (due to OOM) without warning and without any safeguards (and possibly for no sane reason
> at all)? If the developers are this stupid, how many other things have they completely screwed up/ignored?
>
> > Personally, I can't see what
> > benefits of not having virtual memory could offset the benefits of having it.
>
> I'm not sure if there's some kind of misunderstanding here,
> or where your "not having virtual memory" came from.
>
> I'm mostly advocating "virtual memory, without overcommit (and with swap)" and thought you are
> advocating "virtual memory, with overcommit (and therefore with OOM killer preventing any software
> from doing anything correctly even when it's entirely possible and very beneficial)".
>
> > If we have page file backed virtual memory, the examples you cite above won't happen that way. Instead
> > you'll see gradual decrease in performance, which may get really bad before total failure (whether that's
> > OOM or slowdown so bad that it disrupts the service, depends on virtual memory configuration).
>
> No (or not necessarily). For example, if there's 2 GiB of RAM and 20 GiB of swap space; and software frequently
> uses 1 GiB of data and rarely uses 21 GiB of data; then it will not be slow at all. Note that this is very
> common for desktop users - e.g. multiple applications and/or multiple browser tabs, with large amounts of
> data, that are left "running" (sometimes for days) where all the data isn't actually accessed.
>
> > The HTTP server example is actually really similar to our build server. If we wished, we could implement
> > things so that only one operation or part of an operation fails due to OOM. But it makes no sense, since
> > virtual memory solves the problem. And it works for all the operations and parts of them. And for future
> > operations we (or some console manufacturer) add. And also for other stuff running on that server.
>
> Virtual memory does not solve the problems caused by allowing overcommit and then finding that
> what the OS committed to is actually needed and doesn't exist, and that "OOM killer" has to screw
> something up without warning and without any chance of avoidance or graceful mitigation.
>
> > It's a nice idea that some process which holds large amounts
> > of memory for caching purposes could release it
> > when server starts to run out. But that doesn't really work
> > on general purpose server. What if there are several
> > independent processes, but they have different idea of what's
> > the limit of "server starting to run out of memory"?
> > The one with more relaxed limit won't free any of its cache before the other one has freed its.
>
> A process releasing its own memory when (e.g.) it tries to allocate more and "mmap()" returns ENOMEM and
> retrying (and succeeding); or cancelling whatever it wanted the extra memory for (and not anything else);
> or providing feadback directly to user/s (e.g. a dialog box so the user immediately knows what happened
> and doesn't have to go hunting for obscure logs); or giving the process a chance to save important data
> to disk so that it's not lost; are all important "first steps" to making software suck less.
>
> They are not the last steps by any means. For example; the system can be augmented by
> per process quotas, or cgroups, and/or by some kind of "low memory notifications" sent
> out by OS (to ask process/es to release some amount of memory if they're able).
>
> - Brendan
>

Well, not over-commit is not exactly side-effect free. Think allocating a large sparse matrix and only writing a few pages worth of it, without over-commit wouldn't you need to allocate all memory up front (for a truly sparse matrix could that not mean not being able to allocate it at all?). My humble take on this is, this is a trade-off which requires a policy decision by the admin/user as there seem to be valid use cases for all possible combinations, no?

< Previous Post in ThreadNext Post in Thread >
TopicPosted ByDate
Nuances related to Spinlock implementation and the Linux SchedulerBeastian2020/01/03 12:46 PM
  Nuances related to Spinlock implementation and the Linux SchedulerMontaray Jack2020/01/03 01:14 PM
    Nuances related to Spinlock implementation and the Linux SchedulerMontaray Jack2020/01/03 01:49 PM
  No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Linus Torvalds2020/01/03 07:05 PM
    No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Beastian2020/01/04 12:03 PM
    No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Malte Skarupke2020/01/04 12:22 PM
      No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Linus Torvalds2020/01/04 01:31 PM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)dmcq2020/01/05 07:33 AM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)smeuletz2020/01/06 02:05 AM
          Do not blame others for your unfinished jobsmeuletz2020/01/06 02:08 AM
            Where did all the experts come from? Did Linus get linked? (NT)anon2020/01/06 04:27 AM
              PhoronixGabriele Svelto2020/01/06 05:04 AM
                PhoronixSalvatore De Dominicis2020/01/06 07:59 AM
            Do not blame anyone. Please give polite, constructive criticismChester2020/01/06 09:17 AM
              Do not blame anyone. Please give polite, constructive criticismsmeuletz2020/01/06 10:11 AM
                Do not blame anyone. Please give polite, constructive criticismChester2020/01/06 10:54 AM
                  Do not blame anyone. Please give polite, constructive criticismsmeuletz2020/01/06 11:33 AM
                    Do not blame anyone. Please give polite, constructive criticismLinus Torvalds2020/01/06 12:58 PM
                      Do not blame anyone. Please give polite, constructive criticismGionatan Danti2020/01/06 01:13 PM
                        Do not blame anyone. Please give polite, constructive criticismLinus Torvalds2020/01/06 01:28 PM
                          Do not blame anyone. Please give polite, constructive criticismGionatan Danti2020/01/06 01:52 PM
                          Do not blame anyone. Please give polite, constructive criticismJohn Scott2020/01/10 08:48 AM
                          Do not blame anyone. Please give polite, constructive criticismsupernovas2020/01/10 10:01 AM
                            Do not blame anyone. Please give polite, constructive criticismLinus Torvalds2020/01/10 12:45 PM
                      Do not blame anyone. Please give polite, constructive criticismsmeuletz2020/01/07 04:07 AM
                        Do not blame anyone. Please give polite, constructive criticismSimon Farnsworth2020/01/07 01:40 PM
                        Do not blame anyone. Please give polite, constructive criticismEtienne2020/01/08 02:08 AM
                          Do not blame anyone. Please give polite, constructive criticismsmeuletz2020/01/08 02:18 AM
                            Do not blame anyone. Please give polite, constructive criticismMichael S2020/01/08 02:56 AM
                      Not deprecating irrelevant API: sched_yield() on quantum computers?smeuletz2020/01/07 04:34 AM
                      Do not blame anyone. Please give polite, constructive criticismmagicalgoat2020/01/09 05:58 PM
                        Do not blame anyone. Please give polite, constructive criticismLinus Torvalds2020/01/09 10:37 PM
                          Do not blame anyone. Please give polite, constructive criticismAnon32020/01/10 04:40 PM
                  Do not blame anyone. Please give polite, constructive criticismrwessel2020/01/06 10:04 PM
                Do not blame anyone. Please give polite, constructive criticismLinus Torvalds2020/01/06 12:11 PM
                  Do not blame anyone. Please give polite, constructive criticismGabriele Svelto2020/01/06 02:36 PM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Howard Chu2020/01/09 11:39 PM
          No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Linus Torvalds2020/01/10 12:30 PM
      No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)president ltd2020/01/04 02:44 PM
    No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Jörn Engel2020/01/04 12:34 PM
      No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Emil Briggs2020/01/04 01:13 PM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Jörn Engel2020/01/04 01:46 PM
      No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Linus Torvalds2020/01/04 02:24 PM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Linus Torvalds2020/01/04 03:54 PM
          No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Jörn Engel2020/01/05 10:21 AM
            No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Linus Torvalds2020/01/05 12:42 PM
              FUTEX_LOCK_PI performanceJörn Engel2020/01/05 02:45 PM
                FUTEX_LOCK_PI performanceLinus Torvalds2020/01/05 04:30 PM
                  FUTEX_LOCK_PI performanceJörn Engel2020/01/05 07:03 PM
                    FUTEX_LOCK_PI performanceRichardC2020/01/06 07:11 AM
                      FUTEX_LOCK_PI performanceLinus Torvalds2020/01/06 01:11 PM
                  FUTEX_LOCK_PI performanceGabriele Svelto2020/01/06 03:20 AM
                    FUTEX_LOCK_PI performancexilun2020/01/06 05:19 PM
                    FUTEX_LOCK_PI performanceKonrad Schwarz2020/01/13 04:36 AM
                      FUTEX_LOCK_PI performanceGabriele Svelto2020/01/13 04:53 AM
                      FUTEX_LOCK_PI performanceSimon Farnsworth2020/01/13 05:36 AM
                      FUTEX_LOCK_PI performancerwessel2020/01/13 06:22 AM
    No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)rainstar2020/01/04 10:58 PM
      No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Charles Ellis2020/01/05 04:00 AM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Richard2020/01/05 09:58 AM
          It's hard to separateMichael S2020/01/05 11:17 AM
            It's hard to separaterainstared2020/01/06 01:52 AM
              It's hard to separateDavid Kanter2020/01/08 09:27 AM
                It's hard to separateAnon2020/01/08 09:37 PM
                  It's hard to separatenone2020/01/08 11:50 PM
                    It's hard to separateAnon2020/01/09 01:41 AM
                      It's hard to separatenone2020/01/09 03:54 AM
                        It's hard to separategallier22020/01/09 04:19 AM
                          It's hard to separateAnon2020/01/09 05:12 AM
                            It's hard to separateAdrian2020/01/09 05:24 AM
                              It's hard to separategallier22020/01/09 05:58 AM
                                It's hard to separateAdrian2020/01/09 07:09 AM
                            It's hard to separategallier22020/01/09 05:42 AM
                        It's hard to separateAdrian2020/01/09 04:41 AM
                        It's hard to separateAnon2020/01/09 05:24 AM
                          It's hard to separategallier22020/01/09 06:07 AM
                          It's hard to separateDavid Hess2020/01/09 09:27 AM
                            It's hard to separateAdrian2020/01/09 10:15 AM
                              It's hard to separateDavid Hess2020/01/09 10:45 AM
                                It's hard to separateAnon2020/01/09 11:15 AM
                                  It's hard to separateAdrian2020/01/09 11:51 AM
                                    It's hard to separateBrett2020/01/09 01:49 PM
                                      Zilog Z8000Brett2020/01/10 10:53 PM
                                        Zilog Z8000David Hess2020/01/11 07:06 AM
                                          Zilog Z8000Adrian2020/01/11 07:29 AM
                                            Zilog Z8000David Hess2020/01/11 08:45 AM
                                              Zilog Z8000Ricardo B2020/01/11 08:04 PM
                                                Zilog Z8000Ronald Maas2020/01/12 10:47 AM
                                                  Zilog Z8000Ricardo B2020/01/12 12:15 PM
                                                    Zilog Z8000Anon2020/01/12 11:34 PM
                                                      Zilog Z8000Jose2020/01/13 01:23 AM
                                                        Zilog Z8000gallier22020/01/13 01:42 AM
                                                          Zilog Z8000Jose2020/01/13 10:04 PM
                                                            Zilog Z8000rwessel2020/01/13 10:40 PM
                                                              Zilog Z8000David Hess2020/01/13 11:35 PM
                                                                Zilog Z8000Simon Farnsworth2020/01/14 03:56 AM
                                                                  Zilog Z8000Michael S2020/01/14 04:09 AM
                                                                    Zilog Z8000Simon Farnsworth2020/01/14 05:06 AM
                                                                      Zilog Z8000David Hess2020/01/14 10:22 AM
                                                                  Zilog Z8000David Hess2020/01/14 10:15 AM
                                                                Zilog Z8000rwessel2020/01/14 04:12 PM
                                                                  286 16 bit I/OTim McCaffrey2020/01/15 11:25 AM
                                                                    286 16 bit I/ODavid Hess2020/01/15 09:17 PM
                                                      Zilog Z8000Ricardo B2020/01/13 11:52 AM
                                                        Zilog Z8000Anon2020/01/13 12:25 PM
                                                          Zilog Z8000David Hess2020/01/13 06:38 PM
                                                            Zilog Z8000rwessel2020/01/13 07:16 PM
                                                              Zilog Z8000David Hess2020/01/13 07:47 PM
                                                          Zilog Z8000someone2020/01/14 07:54 AM
                                                            Zilog Z8000Anon2020/01/14 08:31 AM
                                                          Zilog Z8000Ricardo B2020/01/14 06:29 PM
                                                  Zilog Z8000Simon Farnsworth2020/01/15 03:26 AM
                                                    Zilog Z8000Tim McCaffrey2020/01/15 11:27 AM
                                                      Zilog Z8000Simon Farnsworth2020/01/15 02:32 PM
                                                    Zilog Z8000Ricardo B2020/01/15 03:47 PM
                                                      Zilog Z8000Anon2020/01/15 04:08 PM
                                                        Zilog Z8000Ricardo B2020/01/15 05:16 PM
                                                          Zilog Z8000Anon2020/01/15 05:31 PM
                                                            Zilog Z8000Ricardo B2020/01/15 06:46 PM
                                                              Zilog Z8000Anon2020/01/15 07:04 PM
                                                                Zilog Z8000David Hess2020/01/15 09:53 PM
                                                                Zilog Z8000Ricardo B2020/01/16 07:27 PM
                                                                  Zilog Z8000Anon2020/01/16 08:33 PM
                                                                    Zilog Z8000Ronald Maas2020/01/17 12:05 AM
                                                                      Zilog Z8000Anon2020/01/17 08:15 AM
                                                                    Zilog Z8000Ricardo B2020/01/17 02:59 PM
                                                                      Zilog Z8000Anon2020/01/17 07:40 PM
                                                                        Zilog Z8000Ricardo B2020/01/18 08:42 AM
                                                                          Zilog Z8000gallier22020/01/19 08:02 AM
                                                                    Zilog Z8000David Hess2020/01/18 07:12 AM
                                                            Zilog Z8000David Hess2020/01/15 09:49 PM
                                                          Zilog Z8000gallier22020/01/16 12:57 AM
                                                      Zilog Z8000Simon Farnsworth2020/01/16 02:30 AM
                                                        IBM PC successEtienne2020/01/16 06:42 AM
                                                        Zilog Z8000Ricardo B2020/01/16 07:32 PM
                                                          Zilog Z8000Brett2020/01/17 01:38 AM
                                                            Zilog Z8000David Hess2020/01/18 07:28 AM
                                                          Zilog Z8000David Hess2020/01/18 07:22 AM
                                                    Zilog Z8000David Hess2020/01/15 09:30 PM
                                            Zilog Z8000Maxwell2020/01/11 09:07 AM
                                              Zilog Z8000David Hess2020/01/11 09:40 AM
                                                Zilog Z8000Maxwell2020/01/11 10:08 AM
                                                  Zilog Z8000Ricardo B2020/01/11 08:42 PM
                                                    8086 does NOT have those addressing modesDevin2020/01/12 02:13 PM
                                                      8086 does NOT have those addressing modesRicardo B2020/01/12 06:46 PM
                                                        8086 does NOT have those addressing modesAnon2020/01/13 05:10 AM
                                                          8086 does NOT have those addressing modesgallier22020/01/13 06:07 AM
                                                            8086 does NOT have those addressing modesAnon2020/01/13 07:09 AM
                                                              8086 does NOT have those addressing modesRicardo B2020/01/13 11:48 AM
                                                          8086 does NOT have those addressing modesMichael S2020/01/13 07:40 AM
                                                            Zilog Z8000Ronald Maas2020/01/13 09:44 AM
                                                              Zilog Z8000Anon2020/01/13 04:32 PM
                                                          8086 does NOT have those addressing modesRicardo B2020/01/13 11:24 AM
                                                            8086 does NOT have those addressing modesrwessel2020/01/13 03:59 PM
                                                              8086 does NOT have those addressing modesDavid Hess2020/01/13 07:12 PM
                                                                8086 does NOT have those addressing modesrwessel2020/01/13 07:28 PM
                                                                  8086 does NOT have those addressing modesDavid Hess2020/01/13 07:51 PM
                                                          8086 does NOT have those addressing modesDavid Hess2020/01/13 06:55 PM
                                            Zilog Z8000rwessel2020/01/11 01:26 PM
                                              Zilog Z8000Brett2020/01/11 03:16 PM
                                                Zilog Z8000rwessel2020/01/11 08:20 PM
                                                  Zilog Z8000Brett2020/01/12 01:02 PM
                                                    Zilog Z8000rwessel2020/01/12 10:06 PM
                                                      Zilog Z8000Brett2020/01/12 11:02 PM
                                                    Zilog Z8000James2020/01/13 06:12 AM
                                              Zilog Z8000Adrian2020/01/12 12:38 AM
                                                PDP-11Michael S2020/01/12 02:33 AM
                                                Zilog Z8000rwessel2020/01/12 07:01 AM
                                              Zilog Z8000Ronald Maas2020/01/12 11:03 AM
                                            Zilog Z8000Konrad Schwarz2020/01/13 04:49 AM
                                              Zilog Z8000Adrian2020/01/14 12:38 AM
                                                Zilog Z8000konrad.schwarz2020/01/15 05:50 AM
                                                  Zilog Z8000Adrian2020/01/15 11:24 PM
                                    It's hard to separateDavid Hess2020/01/11 07:08 AM
                                  It's hard to separateDavid Hess2020/01/11 07:11 AM
                                It's hard to separateAdrian2020/01/09 12:16 PM
                                  It's hard to separateDavid Hess2020/01/11 07:17 AM
                                It's hard to separategallier22020/01/10 01:11 AM
                                  It's hard to separatenone2020/01/10 02:58 AM
                        It's hard to separaterwessel2020/01/09 08:00 AM
                        It's hard to separateDavid Hess2020/01/09 09:10 AM
                          It's hard to separaterwessel2020/01/09 09:51 AM
                  It's hard to separateAdrian2020/01/08 11:58 PM
                    It's hard to separaterwessel2020/01/09 07:31 AM
                      It's hard to separateAdrian2020/01/09 07:44 AM
                    It's hard to separateDavid Hess2020/01/09 09:37 AM
                      It's hard to separatenone2020/01/09 10:34 AM
                  Are segments so bad?Paul A. Clayton2020/01/09 03:15 PM
                    Yes, they are terrible (NT)Anon2020/01/09 03:20 PM
                    Are segments so bad?Adrian2020/01/10 12:49 AM
                      Are segments so bad?Etienne2020/01/10 02:28 AM
                        Are segments so bad?gallier22020/01/10 02:37 AM
                          Are segments so bad?Adrian2020/01/10 03:19 AM
                            Are segments so bad?Adrian2020/01/10 04:27 AM
                              Are segments so bad?Etienne2020/01/10 04:41 AM
                        Are segments so bad?Adrian2020/01/10 03:05 AM
                          Are segments so bad?gallier22020/01/10 03:13 AM
                      Are segments so bad?Anon32020/01/10 11:37 AM
                        Are segments so bad?Adrian2020/01/10 11:47 AM
                          Are segments so bad?Brendan2020/01/11 01:43 AM
                      Are segments so bad?Anon2020/01/10 06:51 PM
                        Are segments so bad?Adrian2020/01/11 01:05 AM
                          Are segments so bad?Jukka Larja2020/01/11 08:20 AM
                            Are segments so bad?Brendan2020/01/11 10:14 AM
                              Are segments so bad?Jukka Larja2020/01/11 09:15 PM
                                Are segments so bad?Brendan2020/01/11 11:15 PM
                                  Are segments so bad?Jukka Larja2020/01/12 04:18 AM
                                  Are segments so bad?anon2020/01/12 12:30 PM
                                    Are segments so bad?Brendan2020/01/12 10:19 PM
                                      the world sucks worse than you're aware ofMichael S2020/01/13 01:50 AM
                                        the world sucks worse than you're aware ofBrendan2020/01/13 03:56 AM
                                        the world sucks worse than you're aware ofGabriele Svelto2020/01/13 04:46 AM
                                      Are segments so bad?Jukka Larja2020/01/13 07:41 AM
                                        Are segments so bad?Brendan2020/01/13 08:21 AM
                                          Are segments so bad?Jukka Larja2020/01/13 09:43 AM
                                            Are segments so bad?Brendan2020/01/13 01:02 PM
                                              Are segments so bad?Anne O. Nymous2020/01/13 01:22 PM
                                                Are segments so bad?Brendan2020/01/13 02:50 PM
                                                  actor of around 200?Michael S2020/01/14 03:58 AM
                                                  Not overcomitting leads to more OOMs, not lessGabriele Svelto2020/01/14 12:50 PM
                                                    Not overcomitting leads to more OOMs, not lessBrendan2020/01/14 01:40 PM
                                                      Not overcomitting leads to more OOMs, not lessGabriele Svelto2020/01/15 03:17 AM
                                                        Not overcomitting leads to more OOMs, not lessAnon2020/01/15 04:43 AM
                                                          Not overcomitting leads to more OOMs, not lessGabriele Svelto2020/01/15 05:09 AM
                                                            Not overcomitting leads to more OOMs, not lessAnon2020/01/15 05:16 AM
                                                              Not overcomitting leads to more OOMs, not lessGabriele Svelto2020/01/15 06:58 AM
                                                                Not overcomitting leads to more OOMs, not lessAnon2020/01/15 09:08 AM
                                                                  Not overcomitting leads to more OOMs, not lessGabriele Svelto2020/01/16 04:05 AM
                                                        Not overcomitting leads to more OOMs, not lessMichael S2020/01/15 04:48 AM
                                                          Not overcomitting leads to more OOMs, not lessGabriele Svelto2020/01/15 05:10 AM
                                                            Not overcomitting leads to more OOMs, not lessMichael S2020/01/15 08:13 AM
                                                              Not overcomitting leads to more OOMs, not lessJukka Larja2020/01/15 08:46 AM
                                                        Not overcomitting leads to more OOMs, not lessJukka Larja2020/01/15 06:08 AM
                                                          Thanks for the info (NT)Gabriele Svelto2020/01/15 07:00 AM
                                                      Not overcomitting leads to more OOMs, not lessLinus Torvalds2020/01/15 12:30 PM
                                                        OOM killer complainsAnon2020/01/15 12:44 PM
                                                          OOM killer complainsanon2020/01/15 04:26 PM
                                                        Not overcomitting leads to more OOMs, not lessBrendan2020/01/16 07:26 AM
                                                          Not overcomitting leads to more OOMs, not lessLinus Torvalds2020/01/16 10:17 AM
                                                            Not overcomitting leads to more OOMs, not lessLinus Torvalds2020/01/16 10:48 AM
                                                              Not overcomitting leads to more OOMs, not lessDoug S2020/01/16 03:41 PM
                                                                Not overcomitting leads to more OOMs, not lessDoug S2020/01/16 03:44 PM
                                                Are segments so bad?rwessel2020/01/13 04:11 PM
                                              Are segments so bad?Jukka Larja2020/01/14 07:37 AM
                                                Are segments so bad?Brendan2020/01/14 08:48 AM
                                                  Are segments so bad?Jukka Larja2020/01/14 11:13 AM
                                                    Are segments so bad?Brendan2020/01/14 02:30 PM
                                                      Are segments so bad?Brett2020/01/14 10:13 PM
                                                      Are segments so bad?Jukka Larja2020/01/15 07:04 AM
                                                  Are segments so bad?Gabriele Svelto2020/01/15 03:35 AM
                                            Specifying cost of dropping pagesPaul A. Clayton2020/01/13 03:00 PM
                                              Specifying cost of dropping pagesrwessel2020/01/13 04:19 PM
                                                Specifying cost of dropping pagesGabriele Svelto2020/01/15 03:23 AM
                                          Are segments so bad?anon2020/01/14 02:15 AM
                                            Are segments so bad?Brendan2020/01/14 06:13 AM
                                          Are segments so bad?Gabriele Svelto2020/01/14 12:57 PM
                                            Are segments so bad?Brendan2020/01/14 02:58 PM
                                              Are segments so bad?Gabriele Svelto2020/01/15 03:33 AM
                                                Are segments so bad?Anon2020/01/15 05:24 AM
                                                  Are segments so bad?Jukka Larja2020/01/15 06:20 AM
                                                Are segments so bad?Etienne2020/01/15 05:56 AM
                                                  Are segments so bad?Jukka Larja2020/01/15 08:53 AM
                                                    Are segments so bad?Gabriele Svelto2020/01/16 06:12 AM
                                                      Are segments so bad?Jukka Larja2020/01/16 10:56 AM
                                                Are segments so bad?Brendan2020/01/15 06:20 AM
                                                  Are segments so bad?Gabriele Svelto2020/01/15 06:56 AM
                                                    Are segments so bad?Brendan2020/01/16 07:16 AM
                                                      Are segments so bad?Jukka Larja2020/01/16 11:08 AM
                                                        Are segments so bad?Brendan2020/01/17 01:52 PM
                                                          Are segments so bad?Jukka Larja2020/01/17 10:08 PM
                                                            Are segments so bad?Brendan2020/01/18 12:40 PM
                                                              Are segments so bad?Jukka Larja2020/01/18 10:13 PM
                                                                Are segments so bad?Brendan2020/01/19 12:25 PM
                                                                  Are segments so bad?Brett2020/01/19 03:18 PM
                                                                    Are segments so bad?Brett2020/01/19 03:34 PM
                                                                  Are segments so bad?Gabriele Svelto2020/01/20 12:57 AM
                                                                  Are segments so bad?Jukka Larja2020/01/20 05:54 AM
                                                                    Are segments so bad?Brendan2020/01/20 12:43 PM
                                                                      Are segments so bad?Jukka Larja2020/01/21 07:01 AM
                                                                        Are segments so bad?Brendan2020/01/21 06:04 PM
                                                                          Are segments so bad?Jukka Larja2020/01/22 07:30 AM
                                                                            Are segments so bad?Brendan2020/01/22 03:56 PM
                                                                              Are segments so bad?Jukka Larja2020/01/23 08:44 AM
                                                      Are segments so bad?rwessel2020/01/16 03:06 PM
                                                      Are segments so bad?Gabriele Svelto2020/01/16 03:13 PM
                                                        Are segments so bad?Brendan2020/01/17 01:51 PM
                                                          Are segments so bad?Gabriele Svelto2020/01/17 03:18 PM
                                                            Are segments so bad?Anon2020/01/17 08:01 PM
                                                              Are segments so bad?Gabriele Svelto2020/01/20 01:06 AM
                                                            Are segments so bad?Brendan2020/01/18 03:15 PM
                                                              Are segments so bad?Gabriele Svelto2020/01/20 12:55 AM
                                                                Are segments so bad?Michael S2020/01/20 05:30 AM
                                                                  Are segments so bad?Gabriele Svelto2020/01/20 08:02 AM
                                                                    Are segments so bad?Jukka Larja2020/01/20 08:41 AM
                                                                    Are segments so bad?Michael S2020/01/20 08:45 AM
                                                                      Are segments so bad?Gabriele Svelto2020/01/20 09:36 AM
                                                                Are segments so bad?Brendan2020/01/20 11:04 AM
                                                                  Are segments so bad?Michael S2020/01/20 01:22 PM
                                                                    Are segments so bad?Brendan2020/01/20 02:38 PM
                                                                      Are segments so bad?Simon Farnsworth2020/01/20 03:40 PM
                                                                        Are segments so bad?Anon2020/01/20 04:35 PM
                                                                          Are segments so bad?Simon Farnsworth2020/01/20 05:30 PM
                                                                      Are segments so bad?Michael S2020/01/20 05:20 PM
                                                                  Are segments so bad?Gabriele Svelto2020/01/21 05:08 AM
                                                                    Are segments so bad?Brendan2020/01/21 06:07 PM
                                                                      Are segments so bad?Gabriele Svelto2020/01/22 01:53 AM
                                                                        Are segments so bad?Brendan2020/01/22 04:32 AM
                                                                          Are segments so bad?Jukka Larja2020/01/22 07:12 AM
                                                                            Are segments so bad?Brendan2020/01/22 04:28 PM
                                                                              Are segments so bad?Jukka Larja2020/01/23 07:36 AM
                                                                                Are segments so bad?Brendan2020/01/24 07:27 PM
                                                                                  Are segments so bad?Jukka Larja2020/01/24 10:42 PM
                                                                                    Are segments so bad?Brendan2020/01/25 02:46 AM
                                                                                      Are segments so bad?Jukka Larja2020/01/25 08:29 AM
                                                                                        Are segments so bad?Brendan2020/01/26 11:17 PM
                                                                                          Are segments so bad?Jukka Larja2020/01/27 07:55 AM
                                                                                            Are segments so bad?Gabriele Svelto2020/01/27 04:33 PM
                                                                                              Are segments so bad?Jukka Larja2020/01/28 06:28 AM
                                                                                                DDS assets and MipMap chainsMontaray Jack2020/01/29 03:26 AM
                                                                                      Are segments so bad?gallier22020/01/27 03:58 AM
                                                                                        Are segments so bad?Jukka Larja2020/01/27 06:19 AM
                                                                                  Are segments so bad?Anne O. Nymous2020/01/25 03:23 AM
                                                                            Are segments so bad?Anon2020/01/22 05:52 PM
                                                                              Are segments so bad?Anne O. Nymous2020/01/23 01:24 AM
                                                                                Are segments so bad?Anon2020/01/23 05:24 PM
                                                                                  Are segments so bad?Anne O. Nymous2020/01/24 12:43 AM
                                                                                    Are segments so bad?Anon2020/01/24 04:04 AM
                                                                                      Are segments so bad?Etienne2020/01/24 06:10 AM
                                                                              Are segments so bad?Gabriele Svelto2020/01/23 01:48 AM
                                                                                Are segments so bad?Michael S2020/01/23 03:48 AM
                                                                                Are segments so bad?Jukka Larja2020/01/23 07:38 AM
                                                                                  Are segments so bad?Gabriele Svelto2020/01/23 01:29 PM
                                                                                    Are segments so bad?Anon2020/01/23 06:08 PM
                                                                                      Are segments so bad?Jukka Larja2020/01/24 09:51 PM
                                                                                Are segments so bad?Anon2020/01/23 06:02 PM
                                                                                  Are segments so bad?Gabriele Svelto2020/01/24 03:57 AM
                                                                                    Are segments so bad?Anon2020/01/24 04:17 AM
                                                                                      Are segments so bad?Gabriele Svelto2020/01/24 09:23 AM
                                                                                        Are segments so bad?Anon2020/02/02 10:15 PM
                                                                                          Are segments so bad?Gabriele Svelto2020/02/03 01:47 AM
                                                                                            Are segments so bad?Anon2020/02/03 02:34 AM
                                                                                              Are segments so bad?Gabriele Svelto2020/02/03 05:36 AM
                                                                                                Are segments so bad?Anon32020/02/03 08:47 AM
                                                                                                Are segments so bad?Anon2020/02/04 05:49 PM
                                                                                  Are segments so bad?Jukka Larja2020/01/24 10:10 PM
                                                          Are segments so bad?Jukka Larja2020/01/17 10:26 PM
                                Are segments so bad?Anne O. Nymous2020/01/12 04:18 AM
                                  Are segments so bad?Jukka Larja2020/01/12 08:41 AM
                            Are segments so bad?rwessel2020/01/11 01:31 PM
                          Are segments so bad?Anne O. Nymous2020/01/11 08:22 AM
                      Are segments so bad?Ricardo B2020/01/11 08:01 PM
                        Are segments so bad?Adrian2020/01/12 12:18 AM
                          Are segments so bad?Michael S2020/01/12 02:43 AM
                            Are segments so bad?Adrian2020/01/12 04:35 AM
                          Are segments so bad?Ricardo B2020/01/12 12:04 PM
                            Are segments so bad?Anon32020/01/12 05:52 PM
                            Are segments so bad?Brendan2020/01/12 09:58 PM
                      Are segments so bad?Paul A. Clayton2020/01/13 09:11 AM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)rainstared2020/01/06 01:43 AM
          No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Foo_2020/01/06 05:33 AM
            No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)dmcq2020/01/06 06:03 AM
            changes in contextCarlie Coats2020/01/09 09:06 AM
      No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)rainstar2020/01/09 10:16 PM
        No nuances, just buggy code (was: related to Spinlock implementation and the Linux Scheduler)Montaray Jack2020/01/09 11:11 PM
    Suggested reading for the authoranon2020/01/04 11:16 PM
      Suggested reading for the authorab2020/01/05 05:15 AM
        Looking at the other side (frequency scaling)Chester2020/01/06 10:19 AM
          Looking at the other side (frequency scaling)Foo_2020/01/06 11:00 AM
          Why spinlocks were usedFoo_2020/01/06 11:06 AM
            Why spinlocks were usedJukka Larja2020/01/06 12:59 PM
            Why spinlocks were usedSimon Cooke2020/01/06 03:16 PM
            Why spinlocks were usedRizzo2020/01/07 01:18 AM
          Looking at the other side (frequency scaling)ab2020/01/07 01:14 AM
    Cross-platform codeGian-Carlo Pascutto2020/01/06 08:00 AM
      Cross-platform codeMichael S2020/01/06 09:11 AM
        Cross-platform codeGian-Carlo Pascutto2020/01/06 12:33 PM
          Cross-platform codeMichael S2020/01/06 01:59 PM
            Cross-platform codeNksingh2020/01/07 12:09 AM
              Cross-platform codeMichael S2020/01/07 02:00 AM
              SRW lock implementationMichael S2020/01/07 02:35 AM
                SRW lock implementationNksingh2020/01/09 02:17 PM
                  broken URL in Linux source codeMichael S2020/01/14 01:56 AM
                    broken URL in Linux source codeTravis Downs2020/01/14 10:14 AM
                      broken URL in Linux source codeMichael S2020/01/14 10:48 AM
                        broken URL in Linux source codeTravis Downs2020/01/14 04:43 PM
                  SRW lock implementation - url brokenMichael S2020/01/14 03:07 AM
                    SRW lock implementation - url brokenTravis Downs2020/01/14 11:06 AM
                      SRW lock implementation - url brokengpderetta2020/01/15 04:28 AM
                        SRW lock implementation - url brokenTravis Downs2020/01/15 11:16 AM
                      SRW lock implementation - url brokenLinus Torvalds2020/01/15 11:20 AM
                        SRW lock implementation - url brokenTravis Downs2020/01/15 11:35 AM
                          SRW lock implementation - url brokenLinus Torvalds2020/01/16 11:24 AM
                    SRW lock implementation - url brokenKonrad Schwarz2020/02/05 10:19 AM
                    SRW lock implementation - url brokennksingh2020/02/05 02:42 PM
      Cross-platform codeLinus Torvalds2020/01/06 01:57 PM
Reply to this Topic
Name:
Email:
Topic:
Body: No Text
How do you spell purple?