blob: 4848c978cf8c8187f86a5c82fd5310f102128a03 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
/*
* Support file for AMDGCN in newlib.
* Copyright (c) 2017 Mentor Graphics.
*
* The authors hereby grant permission to use, copy, modify, distribute,
* and license this software and its documentation for any purpose, provided
* that existing copyright notices are retained in all copies and that this
* notice is included verbatim in any distributions. No written agreement,
* license, or royalty fee is required for any of the authorized uses.
* Modifications to this software may be copyrighted by their authors
* and need not follow the licensing terms described here, provided that
* the new terms are clearly indicated on the first page of each file where
* they apply.
*/
#include <stdlib.h>
#include <stdint.h>
#include <reent.h>
/* _sbrk_r expects us to use the real errno, not the reentrant one. */
#include <errno.h>
#undef errno
extern int errno;
/* The runtime passes in heap space like this. */
struct heap {
int64_t size;
char data[0];
};
static char *__heap_ptr = (char*)-1;
static char *__heap_end = (char*)-1;
static int __heap_lock = 0;
static void *__heap_lock_id = NULL;
static int __heap_lock_cnt = 0;
void *
sbrk (ptrdiff_t nbytes)
{
if (__heap_ptr == (char *)-1)
{
/* Find the heap from kernargs.
The kernargs pointer is in s[8:9].
This will break if the enable_sgpr_* flags are ever changed. */
char *kernargs;
asm ("s_mov_b64 %0, s[8:9]" : "=Sg"(kernargs));
/* The heap data is at kernargs[3]. */
struct heap *heap = *(struct heap **)(kernargs + 24);
__heap_ptr = heap->data;
__heap_end = __heap_ptr + heap->size;
}
if ((__heap_ptr + nbytes) >= __heap_end)
{
errno = ENOMEM;
return (void*)-1;
}
char *base = __heap_ptr;
__heap_ptr += nbytes;
return base;
}
void
__malloc_lock (struct _reent *reent)
{
void *id = reent;
if (id == __heap_lock_id)
{
if (__heap_lock_cnt < 1)
abort ();
++__heap_lock_cnt;
return;
}
while (__sync_lock_test_and_set (&__heap_lock, 1))
/* A sleep seems like it should allow the wavefront to yeild (maybe?)
Use the shortest possible sleep time of 1*64 cycles. */
asm volatile ("s_sleep\t1" ::: "memory");
if (__heap_lock_id != NULL)
abort ();
if (__heap_lock_cnt != 0)
abort ();
__heap_lock_cnt = 1;
__heap_lock_id = id;
}
void
__malloc_unlock (struct _reent *reent)
{
void *id = reent;
if (id != __heap_lock_id)
abort ();
if (__heap_lock_cnt < 1)
abort ();
--__heap_lock_cnt;
if (__heap_lock_cnt > 0)
return;
__heap_lock_id = NULL;
__sync_lock_release (&__heap_lock);
}
|
