AMD APU Windows 10 freezing for 1 second

Dotyczy procesorów

  • E1-2100 APU with Radeon HD (2000, 3000, 4000, 8210)

Problem

Objawem jest zamrażanie wskaźnika myszki na niecałą sekundę, poźniej dwie sekundy normalnej pracy.

W tym samym czasie zużycie procesora przez proces System jest na poziomie ok 50-98%, nie ma możliwości normalnej pracy na komputerze.

Winnym jest sterownik karty graficznej. konieczne jest jego usunięcie i zainstalowanie sterownika Podstawowe urządzenie VGA. Niestety nie mamy wtedy dostępnej akceleracji sprzętowej grafiki, ale to jedyne rozwiązanie. AMD ani Microsoft znają problem od conajmniej 2017 roku i nikt zz tym nic nie robi, ponieważ lista urządzeń nie jest długa a okres wsparcia dla nich już miną.

Na zagranicznych formach można znaleźć podobne informacje zamiennie z zachętą do wymiany komputera na nowy :).

Rozwiązanie

Konieczne jest usunięcie sterownika urządzenia aby korzystał z podstawowego urządzenia VGA.

  1. Usuwamy urzadzenie w menadżerze urządzeń z zaznaczoną opcją usunięcia oprogramowanie.
  2. Pauzujemy aktualizacje automatyczne w ustawieniach systemu.
  3. Skanujemy w poszukiwaniu nowych urządzeń.
  4. Uruchamiamy narzędzie od MS Windows Update Show Hide (download.microsoft.com)
  5. Wybieramy opcję ukryj aktualizacje: wybieramy Advenced Micro Devices…. i dalej. Spowoduje to zablokowanie aktualizacji która powoduje instalację sterownika który jest odpowiedzialny za nasz problem.
  6. Enjoy AMD shit!

Asus f555l, k555 nie widzi dysku, nie odtwarza dźwięku, nie świecą lampki na obudowie

Objawy (Symptoms)

  • W BIOS nie widać dysku (BIOS: hard drive is not present)
  • brak dźwięku w systemie pomimo prawidłowo zainstalowanych sterowników (jeżeli system się już uruchomi) [no sound in system even drivers are installed propoerly]
  • trzeszczący dźwięk mimo nowych głośników (jeżeli system się już uruchomi) [scrachy sound even speakers are new]
  • nieprawidłowo pracują kontrolki (lampki) stanu notebooka [“blinkers?” not working properly]

I jeszcze kilka innych modeli. Konstrukcja ta w środku wygląda jak poniżej:

Przyczyny

Problemem jest złącze znajdujące się tutaj:

Samo złącze wyglada tak:

Naprawa

Złącze to ulega uszkodzeniu, podejrzewam, że niewielki udar (upadek, uderzenie) lub trzymanie otworzonego notebooka za jeden z narożników może powodować naprężenia również w środku które powodują uszkodzenie złącza.

Złącze to ma kilkadziesiąt połączeń na długości ok centymetra. Sam koszt złącza (nieoryginalne) to ponad 70zł (02.2020), wymiana to ok 150zł.

Lista modeli

Konstrukcja ta występuje również w innych notebookach. Poniżej będzie aktualizowana lista:

  • F555L
  • K555L
  • K556L

Algorytm Dijkstry (w trakcie pisania)

Wyszukiwanie najkrótszej drogi między parą wierzchołków w grafie

Algorytm Floyda-Warshalla w przeciwieństwie do algorytmu Dijkstry można było zastosować w grafach z ujemnymi wagami krawędzi, warunkiem było aby w grafie nie występowały ujemne pętle.

Algorytm Dijkstry jest algorytmem zachłannym czyli w celu wyznaczenia rozwiązania w każdym kroku dokonuje zachłannego, najlepiej rokującego w danej chwili rozwiązania częściowego. Podczas pracy algorytmu nie jest dokonywana ocena odnośnie całokształtu jedynie ocena lokalna i wybierane jest rozwiązanie lokalnie optymalne.

Przykładowe zastosowanie algorytmu Dijkstry

Algorytm ten może być wykorzystywany przy obliczaniu najkrótszej drogi na mapie zakładając, że każde skrzyżowanie to wierzchołek a odległości między nimi to wagi. Również jest wykorzystywany przy trasowaniu w sieciach komputerowych w protokole OSPF (wiki).

Działanie algorytmu

Algorytm polega na wybieraniu drogi, która w danej chwili ma najniższy koszt. Startując z wierzchołka s szukamy wagi która jest najniższa i przechodzimy do wierzchołka po tej krawędzi.

Algorytm ten również ma złożoność O(n2) zaś Floyda-Warshalla O(n3). Również jego zaletą jest to, że nie są obliczane wszystkie odległości tylko wyszukiwana ta do celu, dzięki czemu może algorytm zakończyć się wcześniej, co nie ma miejsca w Floydzie-Warshallu. Również tam gdzie graf się zmienia warto rozważyć ten algorytm, przy niezmiennych Floyd-Warshall.

Implementacja kodu

Do testowania implementacji zastosujemy ten sam graf co w algorytmie Floyda-Warshalla:

Ryc. 1. Graf do testowania implementacji kodu
Ryc. 2. Macierz sąsiedztwa grafu z Ryc. 1.
using System;

namespace Dijkstra
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Przykładowa implementacja algorytmu Dijkstry");

            //przygotowanie danych
            //utworzenie tablicy
            int rozmiar_tablicy = 5; //ilosc wierzchołków grafu
            var tablica = new int[rozmiar_tablicy, rozmiar_tablicy];

            //wypełnienie tablicy

            for (int i = 0; i < rozmiar_tablicy; i++)
                for (int j = 0; j < rozmiar_tablicy; j++)
                {
                    tablica[i, j] = Dijkstra.INFINITI;
                }

            //uzupełnienie macierzy sąsiedztwa
            //tablica zaharkodowana, najlepiej by było przekazywać macierz jako parametr
            tablica[0, 1] = 2;
            tablica[0, 2] = 3;
            tablica[1, 3] = 3;
            tablica[1, 4] = 7;
            tablica[2, 3] = 4;
            tablica[3, 4] = 1;

            //utworzenie instancji klasy
            var dijkstra = new Dijkstra(tablica);

            //pobranie ścieżki między wierzchołkami podanymi w parametrze metody
            var test = dijkstra.GetPath(0, 4);

            foreach (var item in test)
            {
                Console.WriteLine(item.ToString());
            };

            Console.ReadLine();
        }

        class Dijkstra
        {
            //stała - nieskończoność
            public const int INFINITI = int.MaxValue;
            public int[,] Tablica { get; set; }
            public Dijkstra(int[,] tablica)
            {
                Tablica = tablica;
            }


            public int[] GetPath(int start, int meta)
            {
                int rozmiarTablicy = Tablica.GetLength(0);
                int[] odleglosc = new int[rozmiarTablicy];
                int[] poprzednik = new int[rozmiarTablicy];
                int[] wezel = new int[rozmiarTablicy];

                for (int i = 0; i < odleglosc.Length; i++)
                {
                    odleglosc[i] = poprzednik[i] = INFINITI;
                    wezel[i] = i;
                }

                odleglosc[start] = 0;

                do
                {
                    int najmniejszy = wezel[0];
                    int najmniejszyIndex = 0;
                    for (int i = 0; i < rozmiarTablicy; i++)
                    {
                        if (odleglosc[wezel[i]] < odleglosc[najmniejszy])
                        {
                            najmniejszy = wezel[i];
                            najmniejszyIndex = i;
                        }
                    }

                    rozmiarTablicy--;
                    wezel[najmniejszyIndex] = wezel[rozmiarTablicy];

                    if (odleglosc[najmniejszy] == INFINITI || najmniejszy == meta)
                    {
                        break;
                    }

                    for (int i = 0; i < rozmiarTablicy; i++)
                    {
                        int j = wezel[i];
                        int nowaOdleglosc = odleglosc[najmniejszy] + Tablica[najmniejszy, j];
                        if (nowaOdleglosc < odleglosc[j])
                        {
                            odleglosc[j] = nowaOdleglosc;
                            poprzednik[j] = najmniejszy;
                        }
                    }
                }
                while (rozmiarTablicy > 0);

                return RekonstruktorSciezki(poprzednik, start, meta);
            }

            public int[] RekonstruktorSciezki(int[] prev, int start, int meta)
            {

                int[] ret = new int[prev.Length];
                int currentNode = 0;
                ret[currentNode] = meta;
                while (ret[currentNode] != INFINITI && ret[currentNode] != start)
                {
                    ret[currentNode + 1] = prev[ret[currentNode]];
                    currentNode++;
                }
                if (ret[currentNode] != start)
                    return null;
                int[] reversed = new int[currentNode + 1];
                for (int i = currentNode; i >= 0; i--)
                    reversed[currentNode - i] = ret[i];
                return reversed;
            }
        }
    }
}