L'ordinateur se bloque lorsque la RAM est presque pleine, peut-être un problème de cache sur le disque.

Cela m'est arrivé lors d'une nouvelle installation d'Ubuntu 14.04.

Dans mon cas, cela n'avait rien à voir avec les problèmes de sysctl mentionnés.

Le problème était plutôt que l'UUID de la partition swap était différent pendant l'installation et après. Ainsi, mon swap n'a jamais été activé, et ma machine se bloquait après quelques heures d'utilisation.

El solution était de vérifier l'UUID actuel de la partition swap avec

sudo blkid

et ensuite sudo nano /etc/fstab pour remplacer la valeur UUID du swap incorrect par celle rapportée par blkid.

Un simple redémarrage pour appliquer les changements, et voilà.

Rien n'a marché pour moi !

J'ai donc écrit un script pour surveiller l'utilisation de la mémoire. Il essaiera d'abord de vider le cache de la RAM si la consommation de mémoire augmente un seuil. Vous pouvez configurer ce seuil sur le script. Si la consommation de mémoire ne descend pas sous le seuil même alors, il commencera à tuer les processus un par un dans l'ordre décroissant de la consommation de mémoire jusqu'à ce que la consommation de mémoire soit inférieure au seuil. Je l'ai fixé à 96% par défaut. Vous pouvez le configurer en modifiant la valeur de la variable RAM_USAGE_THRESHOLD dans le script.

Je suis d'accord que tuer les processus qui consomment beaucoup de mémoire n'est pas la solution parfaite, mais il vaut mieux tuer UNE application plutôt que de perdre TOUT le travail ! !! le script vous enverra une notification de bureau si l'utilisation de la RAM augmente le seuil. Il vous notifiera également s'il tue un processus.

#!/usr/bin/env python
import psutil, time
import tkinter as tk
from subprocess import Popen, PIPE
import tkinter
from tkinter import messagebox
root = tkinter.Tk()
root.withdraw()

RAM_USAGE_THRESHOLD = 96
MAX_NUM_PROCESS_KILL = 100

def main():
    if psutil.virtual_memory().percent >= RAM_USAGE_THRESHOLD:
        # Clear RAM cache
        mem_warn = "Memory usage critical: {}%\nClearing RAM Cache".\
            format(psutil.virtual_memory().percent)
        print(mem_warn)
        Popen("notify-send \"{}\"".format(mem_warn), shell=True)
        print("Clearing RAM Cache")
        print(Popen('echo 1 > /proc/sys/vm/drop_caches',
                    stdout=PIPE, stderr=PIPE,
                    shell=True).communicate())
        post_cache_mssg = "Memory usage after clearing RAM cache: {}%".format(
                            psutil.virtual_memory().percent)
        Popen("notify-send \"{}\"".format(post_cache_mssg), shell=True)
        print(post_cache_mssg)

        if psutil.virtual_memory().percent < RAM_USAGE_THRESHOLD:
            print("Clearing RAM cache saved the day")
            return
        # Kill top C{MAX_NUM_PROCESS_KILL} highest memory consuming processes.
        ps_killed_notify = ""
        for i, ps in enumerate(sorted(psutil.process_iter(),
                                      key=lambda x: x.memory_percent(),
                                      reverse=True)):
            # Do not kill root
            if ps.pid == 1:
                continue
            elif (i > MAX_NUM_PROCESS_KILL) or \
                    (psutil.virtual_memory().percent < RAM_USAGE_THRESHOLD):
                messagebox.showwarning('Killed proccess - save_hang',
                                       ps_killed_notify)
                Popen("notify-send \"{}\"".format(ps_killed_notify), shell=True)
                return
            else:
                try:
                    ps_killed_mssg = "Killed {} {} ({}) which was consuming {" \
                                     "} % memory (memory usage={})". \
                        format(i, ps.name(), ps.pid, ps.memory_percent(),
                               psutil.virtual_memory().percent)
                    ps.kill()
                    time.sleep(1)
                    ps_killed_mssg += "Current memory usage={}".\
                        format(psutil.virtual_memory().percent)
                    print(ps_killed_mssg)
                    ps_killed_notify += ps_killed_mssg + "\n"
                except Exception as err:
                    print("Error while killing {}: {}".format(ps.pid, err))
    else:
        print("Memory usage = " + str(psutil.virtual_memory().percent))
    root.update()

if __name__ == "__main__":
    while True:
        try:
            main()
        except Exception as err:
            print(err)
        time.sleep(1)

Enregistrez le code dans un fichier appelé save_hang.py. Exécutez le script comme :

sudo python save_hang.py

Veuillez noter que ce script est compatible pour Python 3 uniquement et nécessite l'installation du paquet tkinter. vous pouvez l'installer comme :

sudo apt-get install python3-tk

J'espère que cela vous aidera...

Je sais que cette question est ancienne, mais j'ai eu ce problème dans Ubuntu (Chrubuntu) 14.04 sur un Chromebook Acer C720. J'ai essayé la solution de Krišjanis Nesenbergs, et cela a fonctionné quelque peu, mais il y a toujours des plantages parfois.

J'ai finalement trouvé une solution qui a fonctionné en installant zram au lieu d'utiliser le swap physique sur le SSD. Pour l'installer, j'ai simplement suivi les instructions aquí comme ceci :

sudo apt-get install zram-config

Ensuite, j'ai pu configurer la taille du zram swap en modifiant /etc/init/zram-config.conf à la ligne 21.

20: # Calculate the memory to user for zram (1/2 of ram)
21: mem=$(((totalmem / 2 / ${NRDEVICES}) * 1024))

J'ai remplacé le 2 par un 1 afin que la taille du zram soit la même que la quantité de ram dont je dispose. Depuis que j'ai fait cela, je n'ai plus eu de freezes ou de non-réponse du système.

Je pense que vous avez réglé votre vm.swappiness à une valeur très basse, ce qui amène le noyau à échanger trop tard, laissant trop peu de RAM pour que le système puisse travailler.

Vous pouvez montrer votre réglage actuel d'échange en exécutant :

sysctl vm.swappiness

Par défaut, cette valeur est fixée à 60. Le site Wiki Ubuntu recommande de le fixer à 10, mais n'hésitez pas à le fixer à une valeur plus élevée. Vous pouvez le modifier en exécutant :

sudo sysctl vm.swappiness=10

Cela le changera pour le session en cours uniquement pour le rendre persistant, vous devez ajouter vm.swappiness = 10 à la /etc/sysctl.conf fichier.

Si votre disque est lent, envisagez d'en acheter un nouveau.