Turnstone Operating System
Loading...
Searching...
No Matches
sync.h File Reference

synchronization interface More...

#include <types.h>
#include <memory.h>

Macros

#define ___CPU_SYNC_H   0
 
#define SYNC_LOCK_SIZE   0x28
 
#define lock_create_with_heap(h)
 macro for creating lock with heap
 
#define lock_create()
 macro for creating lock with default heap
 
#define lock_create_for_future(tid)
 macro for creating future lock with default heap
 
#define semaphore_create(c)
 creats sempahore at default heap with count
 
#define semaphore_acquire(s)
 acquires one slot at semaphore
 
#define semaphore_release(s)
 releases one slot at semaphore
 

Functions

lock_tlock_create_with_heap_for_future (memory_heap_t *heap, boolean_t for_future, uint64_t task_id)
 creates lock
 
int8_t lock_destroy (lock_t *lock)
 destroys lock
 
void lock_acquire (lock_t *lock)
 acquires lock
 
void lock_release (lock_t *lock)
 relaases lock
 
semaphore_tsemaphore_create_with_heap (memory_heap_t *heap, uint64_t count)
 create semaphore
 
int8_t semaphore_destroy (semaphore_t *semaphore)
 destroys semaphore
 
int8_t semaphore_acquire_with_count (semaphore_t *semaphore, uint64_t count)
 acquires slots at semaphore
 
int8_t semaphore_release_with_count (semaphore_t *semaphore, uint64_t count)
 releases slots at semaphore
 

Detailed Description

synchronization interface

This work is licensed under TURNSTONE OS Public License. Please read and understand latest version of Licence.

Macro Definition Documentation

◆ ___CPU_SYNC_H

#define ___CPU_SYNC_H   0

prevent duplicate header error macro

◆ lock_create

#define lock_create ( )
Value:
#define lock_create_with_heap(h)
macro for creating lock with heap
Definition sync.h:44

macro for creating lock with default heap

◆ lock_create_for_future

#define lock_create_for_future ( tid)
Value:
lock_t * lock_create_with_heap_for_future(memory_heap_t *heap, boolean_t for_future, uint64_t task_id)
creates lock
Definition sync.64.c:63

macro for creating future lock with default heap

◆ lock_create_with_heap

#define lock_create_with_heap ( h)
Value:

macro for creating lock with heap

Parameters
[in]hheap

◆ semaphore_acquire

#define semaphore_acquire ( s)
Value:
int8_t semaphore_acquire_with_count(semaphore_t *semaphore, uint64_t count)
acquires slots at semaphore
Definition sync.64.c:187

acquires one slot at semaphore

Parameters
[in]ssemaphore to acquire

◆ semaphore_create

#define semaphore_create ( c)
Value:
semaphore_t * semaphore_create_with_heap(memory_heap_t *heap, uint64_t count)
create semaphore
Definition sync.64.c:166

creats sempahore at default heap with count

Parameters
[in]ccount

◆ semaphore_release

#define semaphore_release ( s)
Value:
int8_t semaphore_release_with_count(semaphore_t *semaphore, uint64_t count)
releases slots at semaphore
Definition sync.64.c:217

releases one slot at semaphore

Parameters
[in]ssemaphore to release

◆ SYNC_LOCK_SIZE

#define SYNC_LOCK_SIZE   0x28

memory size for lock

Function Documentation

◆ lock_acquire()

void lock_acquire ( lock_t * lock)

acquires lock

Parameters
[in]locklock to acquire

◆ lock_create_with_heap_for_future()

lock_t * lock_create_with_heap_for_future ( memory_heap_t * heap,
boolean_t for_future,
uint64_t task_id )

creates lock

Parameters
[in]heapheap for lock
[in]for_futureis lock for future
Returns
lock

◆ lock_destroy()

int8_t lock_destroy ( lock_t * lock)

destroys lock

Parameters
[in]locklock to destroy
Returns
0 if succeed

◆ lock_release()

void lock_release ( lock_t * lock)

relaases lock

Parameters
[in]locklock to release

◆ semaphore_acquire_with_count()

int8_t semaphore_acquire_with_count ( semaphore_t * semaphore,
uint64_t count )

acquires slots at semaphore

Parameters
[in]semaphoresemaphore to acquire
[in]countsemaphore decrease value
Returns
0 if succeed, or waits

◆ semaphore_create_with_heap()

semaphore_t * semaphore_create_with_heap ( memory_heap_t * heap,
uint64_t count )

create semaphore

Parameters
[in]heapheap where semaphore resides
[in]countsemaphore count value
Returns
semaphore

◆ semaphore_destroy()

int8_t semaphore_destroy ( semaphore_t * semaphore)

destroys semaphore

Parameters
[in]semaphoresemaphore to destroy

◆ semaphore_release_with_count()

int8_t semaphore_release_with_count ( semaphore_t * semaphore,
uint64_t count )

releases slots at semaphore

Parameters
[in]semaphoresemaphore to release
[in]countsemaphore increase value
Returns
0 if succeed