---

virtmem.h

Go to the documentation of this file.

// See the end of this file for license information.

#ifndef TORSION_VIRTMEM_H
#define TORSION_VIRTMEM_H

#include "asm.h"

class Virtual_memory;
extern Virtual_memory virtual_mem;
class Chunk;


class Virtual_memory {
protected:
  Chunk* curr_free_chunk;               
  Chunk* free_list_head;                
  Chunk* free_list_tail;                

public:
  void* managed_mem_start;              

  void
  init();

  void*
  alloc(unsigned int request_size);

  void
  free(void* data_address);
};


class Chunk {
protected:
  unsigned int size_and_flags;          


public:
  Chunk* forward;                       

  Chunk* back;                          

  static const unsigned int PREV_IN_USE = 1<<0;
  static const unsigned int NEXT_IN_USE = 1<<1;
  static const unsigned int STATUS_MASK = PREV_IN_USE | NEXT_IN_USE;
  static const unsigned int SIZE_MASK = ~STATUS_MASK;
  static const unsigned int ALIGNMENT = sizeof(unsigned int) - 1;
  static const unsigned int USED_HEADER_SIZE = sizeof(unsigned int);
  static const unsigned int UNUSED_HEADER_SIZE = USED_HEADER_SIZE +
                                                 sizeof(Chunk*) * 2;
  static const unsigned int FOOTER_SIZE = sizeof(unsigned int);

  inline void
  set_size(unsigned int chunk_size, bool previous_in_use, bool next_in_use) {
    unsigned int flags = 0;             // set header chunk size/flags tag
    if (previous_in_use) flags |= PREV_IN_USE;
    if (next_in_use) flags |= NEXT_IN_USE;
    size_and_flags = (chunk_size & SIZE_MASK) | flags;
                                        // set footer chunk size tag
    *((unsigned int*)((unsigned char*)this + size()) - 1) = size();
  }

  inline void
  set_previous_in_use(bool previous_in_use) {
    if (previous_in_use)
      size_and_flags |= PREV_IN_USE;
    else
      size_and_flags &= ~PREV_IN_USE;
  }
  
  inline void
  set_next_in_use(bool next_in_use) {
    if (next_in_use)
      size_and_flags |= NEXT_IN_USE;
    else
      size_and_flags &= ~NEXT_IN_USE;
  }
  
  inline unsigned int
  size() {
    return size_and_flags & SIZE_MASK;
  }

  inline unsigned int
  previous_size() {
    return *((unsigned int*)this - 1);
  }
  
  inline Chunk*
  previous_chunk() {
    Chunk* prior_chunk = (Chunk*)((unsigned char*)this - previous_size());
    if ((void*)prior_chunk < virtual_mem.managed_mem_start)
      return NULL;
    return prior_chunk;
  }
  
  inline Chunk*
  next_chunk() {
    Chunk* subsequent_chunk = (Chunk*)((unsigned char*)this + size());
    if (subsequent_chunk < this)        // check for wrap-around
      return NULL;
    return subsequent_chunk;
  }

  inline bool
  is_previous_in_use() {
    if (size_and_flags & PREV_IN_USE)
      return true;
    return false;
  }
  
  inline bool
  is_next_in_use() {
    if (size_and_flags & NEXT_IN_USE)
      return true;
    return false;
  }

  inline void*
  data_address() {
    return (unsigned char*)this + USED_HEADER_SIZE;
  }

  static inline Chunk*
  convert_data_address_to_chunk(void* data_address) {
    return (Chunk*)((unsigned char*)data_address - USED_HEADER_SIZE);
  }

  static inline unsigned int
  align(unsigned int byte_size) {
    if (byte_size & ALIGNMENT)          // if unaligned, align it (round up)
      return (byte_size & ~ALIGNMENT) + ALIGNMENT + 1;
    return byte_size;
  }

  static inline void*
  align(void* address) {
    return (void*)Chunk::align((unsigned int)address);
  }
};

#endif

/* Torsion Operating System, Copyright (C) 2000-2002 Dan Helfman
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details (in the COPYING file).
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

---

Torsion Operating System, Copyright (C) 2000-2002 Dan Helfman