Subversion Repositories HelenOS

Rev

Rev 2021 | Rev 2042 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2021 Rev 2028
Line 23... Line 23...
23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 23 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 24 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 25 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 26 
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
 */
 27 
 */
- 
 
 28 
 
28 
#include <print.h>
 29 
#include <print.h>
29 
#include <test.h>
 30 
#include <test.h>
30 
#include <mm/page.h>
 31 
#include <mm/page.h>
31 
#include <mm/frame.h>
 32 
#include <mm/frame.h>
32 
#include <mm/slab.h>
 33 
#include <mm/slab.h>
Line 36... Line 37...
36 
#include <debug.h>
 37 
#include <debug.h>
37 
#include <proc/thread.h>
 38 
#include <proc/thread.h>
38 
#include <memstr.h>
 39 
#include <memstr.h>
39 
#include <arch.h>
 40 
#include <arch.h>
40 
 
 41 
 
41 
#ifdef CONFIG_BENCH
 - 
 
42 
#include <arch/cycle.h>
 - 
 
43 
#endif
 - 
 
44 
 
 - 
 
45 
#define MAX_FRAMES 256
 42 
#define MAX_FRAMES 256
46 
#define MAX_ORDER 8
 43 
#define MAX_ORDER 8
47 
 
 44 
 
48 
#define THREAD_RUNS 1
 45 
#define THREAD_RUNS 1
49 
#define THREADS 8
 46 
#define THREADS 8
50 
 
 47 
 
51 
static void falloc(void * arg);
 - 
 
52 
static void failed(void);
 - 
 
53 
 
 - 
 
54 
static atomic_t thread_count;
 48 
static atomic_t thread_count;
- 
 
 49 
static atomic_t thread_fail;
55 
 
 50 
 
56 
void falloc(void * arg)
 51 
static void falloc(void * arg)
57 
{
 52 
{
58 
    int order, run, allocated, i;
 53 
    int order, run, allocated, i;
59 
    uint8_t val = THREAD->tid % THREADS;
 54 
    uint8_t val = THREAD->tid % THREADS;
60 
    index_t k;
 55 
    index_t k;
61 
   
 56 
   
62 
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
 57 
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
63 
    ASSERT(frames != NULL);
 58 
    if (frames == NULL) {
- 
 
 59 
        printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
- 
 
 60 
        atomic_inc(&thread_fail);
- 
 
 61 
        atomic_dec(&thread_count);
- 
 
 62 
        return;
- 
 
 63 
    }
64 
   
 64 
   
65 
    thread_detach(THREAD);
 65 
    thread_detach(THREAD);
66 
 
 66 
 
67 
    for (run = 0; run < THREAD_RUNS; run++) {
 67 
    for (run = 0; run < THREAD_RUNS; run++) {
68 
        for (order = 0; order <= MAX_ORDER; order++) {
 68 
        for (order = 0; order <= MAX_ORDER; order++) {
Line 71... Line 71...
71 
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
 71 
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
72 
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
 72 
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
73 
                if (frames[allocated]) {
 73 
                if (frames[allocated]) {
74 
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
 74 
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
75 
                    allocated++;
 75 
                    allocated++;
76 
                } else {
 76 
                } else
77 
                    break;
 77 
                    break;
78 
                }
 - 
 
79 
            }
 78 
            }
80 
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
 79 
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
81 
 
 80 
 
82 
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
 81 
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
83 
            for (i = 0; i < allocated; i++) {
 82 
            for (i = 0; i < allocated; i++) {
84 
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
 83 
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
85 
                    if (((uint8_t *) frames[i])[k] != val) {
 84 
                    if (((uint8_t *) frames[i])[k] != val) {
86 
                        printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
 85 
                        printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
- 
 
 86 
                        atomic_inc(&thread_fail);
87 
                        failed();
 87 
                        goto cleanup;
88 
                    }
 88 
                    }
89 
                }
 89 
                }
90 
                frame_free(KA2PA(frames[i]));
 90 
                frame_free(KA2PA(frames[i]));
91 
            }
 91 
            }
92 
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
 92 
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
93 
        }
 93 
        }
94 
    }
 94 
    }
95 
   
 95 
 
- 
 
 96 
cleanup:   
96 
    free(frames);
 97 
    free(frames);
97 
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
 98 
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
98 
    atomic_dec(&thread_count);
 99 
    atomic_dec(&thread_count);
99 
}
 100 
}
100 
 
 101 
 
101 
 
 - 
 
102 
void failed(void)
 102 
char * test_falloc2(void)
103 
{
 103 
{
104 
    panic("Test failed.\n");
 - 
 
105 
}
 - 
 
106 
 
 - 
 
107 
 
 - 
 
108 
void test_falloc2(void)
 - 
 
109 
{
 - 
 
110 
#ifdef CONFIG_BENCH
 - 
 
111 
    uint64_t t0 = get_cycle();
 - 
 
112 
#endif
 - 
 
113 
    int i;
 104 
    unsigned int i;
114 
 
 105 
 
115 
    atomic_set(&thread_count, THREADS);
 106 
    atomic_set(&thread_count, THREADS);
- 
 
 107 
    atomic_set(&thread_fail, 0);
116 
       
 108 
       
117 
    for (i = 0; i < THREADS; i++) {
 109 
    for (i = 0; i < THREADS; i++) {
118 
        thread_t * thrd;
 - 
 
119 
        thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
 110 
        thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
120 
        if (thrd)
 111 
        if (!thrd) {
- 
 
 112 
            printf("Could not create thread %d\n", i);
121 
            thread_ready(thrd);
 113 
            break;
122 
        else
 114 
        }
123 
            failed();
 115 
        thread_ready(thrd);
124 
    }
 116 
    }
125 
   
 117 
   
126 
    while (thread_count.count)
 118 
    while (atomic_get(&thread_count) > 0) {
- 
 
 119 
        printf("Threads left: %d\n", atomic_get(&thread_count));
- 
 
 120 
        thread_sleep(1);
127 
        ;
 121 
    }
128 
 
 122 
   
129 
    printf("Test passed.\n");
 123 
    if (atomic_get(&thread_fail) == 0)
130 
#ifdef CONFIG_BENCH
 124 
        return NULL;
- 
 
 125 
   
131 
    uint64_t dt = get_cycle() - t0;
 126 
    return "Test failed";
132 
    printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt);
 - 
 
133 
#endif
 - 
 
134 
}
 127 
}