os.c File Reference

Low-level OS interface. More...

#include "internal.h"

Include dependency graph for os.c:

Go to the source code of this file.

Functions
static void *	_tm_os_alloc_ (long size)
	Allocate memory from the OS.
static void *	_tm_os_free_ (void *ptr, long size)
	Return memory back to the OS.
static __inline void *	_tm_os_alloc (long size)
	Allocate memory from OS.
static __inline void *	_tm_os_free (void *ptr, long size)
	Return block to the OS.
void *	_tm_os_alloc_aligned (size_t size)
	Allocate a aligned buffer aligned to tm_block_SIZE from the OS.
void	_tm_os_free_aligned (void *ptr, size_t size)
	Free an aligned buffer back to the OS.
Variables
size_t	tm_os_alloc_total = 0
	Total bytes currently allocated from OS.

---

Detailed Description

Low-level OS interface.

Definition in file os.c.

---

Function Documentation

void* _tm_os_alloc_aligned

(

size_t

size

)

Allocate a aligned buffer aligned to tm_block_SIZE from the OS.

Return 0 if OS could not allocate a buffer.

Check alignment:

If pointer to OS block is not aligned to tm_block_SIZE,

Compute a new size to allow for alignment.

 |<--- tm_BLOCK_SIZE --->|<--- tm_BLOCK_SIZE -->|
 +----------------------------------------------...
 |<--- offset --->|<--- size      --->|
 |                |<-lo->|<--- sh --->|
 +----------------------------------------------...
                  ^      ^
                  |      |
                  ptr    nb

Give the block back to the OS.

Try again with more room for realignment.

Return 0 if OS would not allocate a bigger buffer.

Realign to tm_block_SIZE.

Assert that alignment is correct.

Return aligned ptr.

Definition at line 216 of file os.c.

References _tm_os_alloc(), _tm_os_free(), tm_assert, tm_block_SIZE, tm_msg(), and tm_ptr_is_aligned_to_block.

Referenced by _tm_block_alloc().

{
  void *ptr;

  tm_assert(tm_ptr_is_aligned_to_block(size));

  ptr = _tm_os_alloc(size);

  /*! Return 0 if OS could not allocate a buffer. */
  if ( ! ptr )
    return 0;

  /**
   * Check alignment:
   *
   * If pointer to OS block is not aligned to tm_block_SIZE,
   */
  if ( ! tm_ptr_is_aligned_to_block(ptr) ) {
    size_t offset = ((unsigned long) ptr) % tm_block_SIZE;
    size_t left_over = tm_block_SIZE - offset;
    size_t new_size = size + left_over;

    /**
     *
     * Compute a new size to allow for alignment.
     *
     * <pre>
     *
     * |<--- tm_BLOCK_SIZE --->|<--- tm_BLOCK_SIZE -->|
     * +----------------------------------------------...
     * |<--- offset --->|<--- size      --->|
     * |                |<-lo->|<--- sh --->|
     * +----------------------------------------------...
     *                  ^      ^
     *                  |      |
     *                  ptr    nb
     *
     * </pre>
     *
     */
    tm_msg("A al %p[%lu] %lu %ld\n", (void *) ptr, (unsigned long) size, (unsigned long) tm_block_SIZE, (long) offset);

    // THREAD-RACE on mmap()? {{{

    /*! Give the block back to the OS. */
    _tm_os_free(ptr, size);

    /*! Try again with more room for realignment. */
    ptr = _tm_os_alloc(new_size);

    // THREAD-RACE on mmap()? }}}

    /*! Return 0 if OS would not allocate a bigger buffer. */
    if ( ! ptr )
      return 0;

    /*! Realign to tm_block_SIZE. */
    offset = ((unsigned long) ptr) % tm_block_SIZE;

    tm_msg("A alr %p[%lu] %ld\n", (void *) ptr, (unsigned long) new_size, (long) offset);

    if ( offset ) {
      left_over = tm_block_SIZE - offset;
      
      ptr += left_over;
      new_size -= left_over;

      /*! Assert that alignment is correct. */
      tm_assert(size == new_size);
      tm_assert(tm_ptr_is_aligned_to_block(ptr));
      tm_assert(tm_ptr_is_aligned_to_block(new_size));
    }
  }

  /*! Return aligned ptr. */
  return ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void _tm_os_free_aligned	(	void *	ptr,
		size_t	size
	)

Free an aligned buffer back to the OS.

Definition at line 298 of file os.c.

References _tm_os_free(), tm_assert_test, and tm_ptr_is_aligned_to_block.

Referenced by _tm_block_free().

{
  tm_assert_test(tm_ptr_is_aligned_to_block(ptr));
  tm_assert_test(tm_ptr_is_aligned_to_block(size));
 
  _tm_os_free(ptr, size);
}

Here is the call graph for this function:

Here is the caller graph for this function: