BirdOs December 2018

maarten70

Gevestigd lid
Het is alweer december en eigenlijk heb ik best weinig gedaan het afgelopen jaar, maar het zijn wel grote en belangrijke milestones geweest. Dit jaar zijn er 3 dingen toegevoegd, waarvan allemaal milestones: Basic PCI, Physical Memory Management en ATA hardeschijven. Ook deze maand is er niet per se veel gebeurd, zo heb ik tijd besteed aan een nieuwe functie voor die memory management, terwijl de functie een dag later weg gehaald is omdat ik malloc() wilde verbeteren.

Nieuw:
- FAT32 read
- Nieuwe text processing features

Verbeteringen:
- Malloc() is efficiënter, maar werkt niet altijd
- Scherm kan weer scrollen


FAT32 read
FAT32 is een bestandssysteem op hardeschijven, het is een erg bekend en simpel bestandssysteem. FAT32 gebruikt een FAT (File Allocation Table), dit is een lijst met locaties van bestanden en mappen. BirdOS kan bestanden zien:



Dit is allemaal getest met een virtuele hardeschijf waar FreeDOS 1.2 op staat. Hierop heb ik dan een tekst bestand aangemaakt op FreeDOS, genaamd WELCOME1.TXT, die BirdOS kan vinden en lezen:



Dit kan je dan vergelijken met een ASCII table en wat ik dan daadwerkelijk getypt heb:



Output van BirdOS: "Welcome, thhis", de tweede 'h' is geen typfout, maar waarschijnlijk een fout bij het lezen of schermschrijven. Maar het idee is er.

Nieuwe text processing features
BirdOS kan tekst opsplitsen en controleren of een deel van een stuk tekst voorkomt in een ander stuk tekst.

Malloc()
Ik heb geprobeerd Malloc() te verbeteren, de functie die zoekt naar een leeg plekje in de RAM, en dit was gelukt. Vandaag kwam ik er alleen achter dat het niet werkte op een andere machine. Deze verbetering is veel efficiënter, veel makkelijker leesbaar en 12 lijnen code minder. Alleen heeft het een probleem: het kan maar 1 plek toewijzen en daarna kan het geen enkele plek meer vinden.

Scherm kan weer scrollen
Het scherm kan weer scrollen. Het kon niet scrollen doordat ik een adres globaal had gemaakt, dus voor alle functies beschikbaar. Elke functie zou dan de pointer verzetten, zo kon ik er zeker van zijn dat elke functie up-to-date was met betrekking tot de plek waar iets geschreven kon worden. Maar hierdoor snapte de scroll functie het allemaal niet meer. De oplossing was best simpel, gewoon de functie een eigen variabele geven.


Dit project was ik begonnen om te leren programmeren en ik merk dat het de afgelopen paar maanden steeds makkelijker voor mij is geworden, zeker deze maand.

Het is ook net iets meer dan twee jaar geleden dat ik op dit forum begonnen ben met updates te schrijven over dit besturingssysteem. Ik vind het hartstikke leuk om ze te schrijven, ik hoop dat ze ook een beetje interessant genoeg zijn om te lezen, en ik ga er graag mee door. Dank jullie allemaal voor het lezen, en het motiveerd mij om te weten dat mensen interesse hebben in dit project.

Bedankt, en alvast fijne kerst en gelukkig nieuwjaar.
 

maarten70

Gevestigd lid
Voor de programmeurs...

De eerste is minder goed leesbaar dan de tweede, vind ik.

Code:
/* Doesn't care about the amount of memory*/
void *malloc(size_t size){
    Memory_table *result = (Memory_table *) 57; // 57 is the error code used when we can't find an empty space
    
    for(Memory_table *tmp = mem_first; result == (Memory_table *) 57; tmp = (Memory_table *) tmp->next)
        if(!tmp->alloct) result = tmp;
        
        if(Mem_allocable > 0){ //if we have enough memory...
            if(result != (Memory_table *) 57 && result->size >= size + sizeof(Memory_table) + 1){ //...and we've found a result + the size is fine for what we need:
                Memory_table *tmpp = (Memory_table *) result + sizeof(Memory_table) + size + 1; /*calculating next location of a new memory info table (for next block)*/
                
                if(tmpp->alloct != true){ //setting up it's info
                    tmpp->alloct = false;
                    tmpp->size = 1024; //tijdelijk, moet verbeterd worden --> too lazy to delete this, it means "temporary, needs to be improved"
                    tmpp->prev = (uint32_t *) result;
                    tmpp->next = result->next;
                }

                result->next = (uint32_t *) tmpp; //tmmp is the next memory info table after this block
                result->size = size;
                result->alloct = true;
                result->prev = (uint32_t *) result - size - sizeof(Memory_table);

            }else if(result != (Memory_table *) 57 && result->size < size + sizeof(Memory_table) + 1){ //...if it needs to be bigger, do almost the smae thing
                Memory_table *tmpp = (Memory_table *) result + sizeof(Memory_table) + size + 1; /*calculating next thing*/

                if(tmpp->alloct != true){ //it's info
                    result->size = size;
                    result->alloct = true;
                    result->next = (uint32_t *) tmpp;
                    result->prev = (uint32_t *) result - 1024 - sizeof(Memory_table);
                    for(Memory_table *temp = (Memory_table *) result->prev; temp->alloct != true; temp = temp - 1) //sort of 'probing' our way to the table location which we very much need
                        if(temp->alloct == true) result->prev = (uint32_t *) temp;
                }else error(56); //if the next block is already allocated, give an error (TODO: Let it search for a new place)

            }else if(result == (Memory_table *) 57) error(57); //if we actually found no place in memory say to the user tha the memory is full

            Mem_allocable--; //This actually ignores the size of the table, stupid me (TODO)
        }else{
            print("\nout of memory!\n");
            error(56); //Illegal operation
        }
        return (void *) ((size_t)result + sizeof(Memory_table)); //location of the memory info table + it's own size, is the key to this problem
}

Code:
void *malloc(size_t size)
{
    int thing = 0;
    
    //check if we have enough memory for the block
    if(MEM_MAX < size)
    {
        error(54); //out of memory
        return 54;
    }

    //search for an empty piece (does not care about the size of a previously allocated block)
    for(int i = 1; i < MEM_TABLE_SIZE; i++)
    {
        if(!mem_table[i]->alloct){
            thing = i;
            i = MEM_TABLE_SIZE + 5;
        }
        
    }

    //check for more errors
    if(thing == MEM_TABLE_SIZE){
        error(57); //couldn't allocate memory
        return 57;
    }

    //allocate, return
    mem_table[thing]->alloct = true;
    mem_table[thing]->loc = mem_table[thing - 1]->next;
    mem_table[thing]->next = mem_table[thing]->loc + size;
    MEM_MAX -= size;
    return mem_table[thing]->loc;
}
 
Bovenaan Onderaan