WebSVN – HelenOS – Diff – /branches/rcu/kernel/test/tasklet/tasklet1.c


/*
 * Copyright (c) 2007 Jan Hudecek
 * Copyright (c) 2005 Jakub Jermar
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <print.h>
#include <arch.h>
#include <test.h>
#include <proc/tasklet.h>
#include <synch/waitq.h>
#include <cpu.h>
#include <proc/thread.h>
#include <arch/types.h>
#include <config.h>
 
static void func(void *data)
{
    printf("cpu%d: %s",CPU->id, data);
}
 
bool gquiet;
#ifdef CONFIG_SMP
 
static void running_tasklet(void * data)
{
    waitq_t wq;
    waitq_initialize(&wq);
 
    tasklet_descriptor_t *tasklet_desc;
    //before we start we need to register a tasklet
    if (!gquiet)
        printf("cpu:%d, Registering tasklet...", CPU->id);
    if (!gquiet)
        tasklet_desc=tasklet_register(&func, "\nTasklet called and received data\n");
    else
        tasklet_desc=tasklet_register(&func, "");
    if (!gquiet)
        printf("Done!\n");
 
    //first we'll try disabling the tasklet
    if (!gquiet)
        printf("cpu:%d, Disabling tasklet...", CPU->id);
    tasklet_disable(tasklet_desc);
    if (!gquiet)
        printf("Done!\n");
 
    //we'll schedule the disabled tasklet
    if (!gquiet)
        printf("cpu:%d, Scheduling tasklet...", CPU->id);
    tasklet_schedule(tasklet_desc);
    if (!gquiet)
        printf("Done!\n");
 
    //and we'll wait if it gets called. It shouldn't however, because it's disabled
    if (!gquiet)
        printf("cpu:%d, Waiting 1s...\n", CPU->id);
    waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
    if (!gquiet)
        printf("cpu:%d, Done!\n", CPU->id);
 
    //then we'll try to enable it
    if (!gquiet)
        printf("cpu:%d, Enabling tasklet...", CPU->id);
    tasklet_enable(tasklet_desc);
    if (!gquiet)
        printf("Done!\n");
   
    //and wait if it gets called this time. It should because it's enabled
    if (!gquiet)
        printf("cpu:%d, Waiting 1s...\n", CPU->id);
    waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
    if (!gquiet)
        printf("cpu:%d, Done!\n", CPU->id);
 
    //finally we'll free the tasklet structure
    if (!gquiet)
        printf("cpu:%d, Freeing...", CPU->id);
    tasklet_free(tasklet_desc);
    if (!gquiet)
        printf("Done!\n");
}
#endif
char * test_tasklet1(bool quiet)
{
    gquiet = quiet;
    waitq_t wq;
    waitq_initialize(&wq);
    tasklet_descriptor_t *tasklet_desc;
 
#ifdef CONFIG_SMP
    thread_t* second_thread = NULL;
    if (!quiet)
        printf("cpus:%d\n", config.cpu_active);
 
    if (config.cpu_active >1) {
        second_thread = thread_create(&running_tasklet, NULL, TASK, THREAD_FLAG_WIRED,"running tasklet", false);
        if (CPU->id == 0)
            second_thread->cpu = &cpus[1];
        else
            second_thread->cpu = &cpus[0];
        thread_ready(second_thread);
    }
#endif
 
    //before we start we need to register a tasklet
    if (!quiet)
        printf("cpu:%d, Registering tasklet...", CPU->id);
    if (!quiet)
        tasklet_desc=tasklet_register(&func, "\nTasklet called and received data\n");
    else
        tasklet_desc=tasklet_register(&func, "");
    if (!quiet)
        printf("Done!\n");
 
    //first we'll try disabling the tasklet
    if (!quiet)
        printf("cpu:%d, Disabling tasklet...", CPU->id);
    tasklet_disable(tasklet_desc);
    if (!quiet)
        printf("Done!\n");
 
    //we'll schedule the disabled tasklet
    if (!quiet)
        printf("cpu:%d, Scheduling tasklet...", CPU->id);
    tasklet_schedule(tasklet_desc);
    if (!quiet)
        printf("Done!\n");
 
    //and we'll wait if it gets called. It shouldn't however, because it's disabled
    if (!quiet)
        printf("cpu:%d, Waiting 1s...\n", CPU->id);
    waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
    if (!quiet)
        printf("cpu:%d, Done!\n", CPU->id);
 
 
    //then we'll try to enable it
    if (!quiet)
        printf("cpu:%d, Enabling tasklet...", CPU->id);
    tasklet_enable(tasklet_desc);
    if (!quiet)
        printf("Done!\n");
   
    //and wait if it gets called this time. It should because it's enabled
    if (!quiet)
        printf("cpu:%d, Waiting 1s...\n", CPU->id);
    waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
    if (!quiet)
        printf("cpu:%d, Done!\n", CPU->id);
#ifdef CONFIG_SMP
        if (config.cpu_active >1) {
            printf("Joining with the second thread...");
            thread_join(second_thread);
            printf("Done\n");
        }
 
#endif
    //finally we'll free the tasklet structure
    if (!quiet)
        printf("cpu:%d, Freeing...", CPU->id);
    tasklet_free(tasklet_desc);
    if (!quiet)
        printf("Done!\n");
 
 
    return NULL;
}
 

Rev 2292	Rev 2307
1	/*	1	/*
2	* Copyright (c) 2007 Jan Hudecek	2	* Copyright (c) 2007 Jan Hudecek
3	* Copyright (c) 2005 Jakub Jermar	3	* Copyright (c) 2005 Jakub Jermar
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	#include <print.h>	30	#include <print.h>
31	#include <arch.h>	31	#include <arch.h>
32	#include <test.h>	32	#include <test.h>
33	#include <proc/tasklet.h>	33	#include <proc/tasklet.h>
34	#include <synch/waitq.h>	34	#include <synch/waitq.h>
35	#include <cpu.h>	35	#include <cpu.h>
36	#include <proc/thread.h>	36	#include <proc/thread.h>
37	#include <arch/types.h>	37	#include <arch/types.h>
38	#include <config.h>	38	#include <config.h>
39		39
40	static void func(void *data)	40	static void func(void *data)
41	{	41	{
42	printf("cpu%d: %s",CPU->id, data);	42	printf("cpu%d: %s",CPU->id, data);
43	}	43	}
44		44
45	bool gquiet;	45	bool gquiet;
-		46	#ifdef CONFIG_SMP
46		47
47	static void running_tasklet(void * data)	48	static void running_tasklet(void * data)
48	{	49	{
49	waitq_t wq;	50	waitq_t wq;
50	waitq_initialize(&wq);	51	waitq_initialize(&wq);
51		52
52	tasklet_descriptor_t *tasklet_desc;	53	tasklet_descriptor_t *tasklet_desc;
53	//before we start we need to register a tasklet	54	//before we start we need to register a tasklet
54	if (!gquiet)	55	if (!gquiet)
55	printf("cpu:%d, Registering tasklet...", CPU->id);	56	printf("cpu:%d, Registering tasklet...", CPU->id);
56	if (!gquiet)	57	if (!gquiet)
57	tasklet_desc=tasklet_register(&func, "\nTasklet called and received data\n");	58	tasklet_desc=tasklet_register(&func, "\nTasklet called and received data\n");
58	else	59	else
59	tasklet_desc=tasklet_register(&func, "");	60	tasklet_desc=tasklet_register(&func, "");
60	if (!gquiet)	61	if (!gquiet)
61	printf("Done!\n");	62	printf("Done!\n");
62		63
63	//first we'll try disabling the tasklet	64	//first we'll try disabling the tasklet
64	if (!gquiet)	65	if (!gquiet)
65	printf("cpu:%d, Disabling tasklet...", CPU->id);	66	printf("cpu:%d, Disabling tasklet...", CPU->id);
66	tasklet_disable(tasklet_desc);	67	tasklet_disable(tasklet_desc);
67	if (!gquiet)	68	if (!gquiet)
68	printf("Done!\n");	69	printf("Done!\n");
69		70
70	//we'll schedule the disabled tasklet	71	//we'll schedule the disabled tasklet
71	if (!gquiet)	72	if (!gquiet)
72	printf("cpu:%d, Scheduling tasklet...", CPU->id);	73	printf("cpu:%d, Scheduling tasklet...", CPU->id);
73	tasklet_schedule(tasklet_desc);	74	tasklet_schedule(tasklet_desc);
74	if (!gquiet)	75	if (!gquiet)
75	printf("Done!\n");	76	printf("Done!\n");
76		77
77	//and we'll wait if it gets called. It shouldn't however, because it's disabled	78	//and we'll wait if it gets called. It shouldn't however, because it's disabled
78	if (!gquiet)	79	if (!gquiet)
79	printf("cpu:%d, Waiting 1s...\n", CPU->id);	80	printf("cpu:%d, Waiting 1s...\n", CPU->id);
80	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);	81	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
81	if (!gquiet)	82	if (!gquiet)
82	printf("cpu:%d, Done!\n", CPU->id);	83	printf("cpu:%d, Done!\n", CPU->id);
83		84
84	//then we'll try to enable it	85	//then we'll try to enable it
85	if (!gquiet)	86	if (!gquiet)
86	printf("cpu:%d, Enabling tasklet...", CPU->id);	87	printf("cpu:%d, Enabling tasklet...", CPU->id);
87	tasklet_enable(tasklet_desc);	88	tasklet_enable(tasklet_desc);
88	if (!gquiet)	89	if (!gquiet)
89	printf("Done!\n");	90	printf("Done!\n");
90		91
91	//and wait if it gets called this time. It should because it's enabled	92	//and wait if it gets called this time. It should because it's enabled
92	if (!gquiet)	93	if (!gquiet)
93	printf("cpu:%d, Waiting 1s...\n", CPU->id);	94	printf("cpu:%d, Waiting 1s...\n", CPU->id);
94	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);	95	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
95	if (!gquiet)	96	if (!gquiet)
96	printf("cpu:%d, Done!\n", CPU->id);	97	printf("cpu:%d, Done!\n", CPU->id);
97		98
98	//finally we'll free the tasklet structure	99	//finally we'll free the tasklet structure
99	if (!gquiet)	100	if (!gquiet)
100	printf("cpu:%d, Freeing...", CPU->id);	101	printf("cpu:%d, Freeing...", CPU->id);
101	tasklet_free(tasklet_desc);	102	tasklet_free(tasklet_desc);
102	if (!gquiet)	103	if (!gquiet)
103	printf("Done!\n");	104	printf("Done!\n");
104	}	105	}
105		106	#endif
106	char * test_tasklet1(bool quiet)	107	char * test_tasklet1(bool quiet)
107	{	108	{
108	gquiet = quiet;	109	gquiet = quiet;
109	waitq_t wq;	110	waitq_t wq;
110	waitq_initialize(&wq);	111	waitq_initialize(&wq);
111	tasklet_descriptor_t *tasklet_desc;	112	tasklet_descriptor_t *tasklet_desc;
112	thread_t* second_thread = NULL;	-
113	#ifdef CONFIG_SMP	113	#ifdef CONFIG_SMP
-		114	thread_t* second_thread = NULL;
114	if (!quiet)	115	if (!quiet)
115	printf("cpus:%d\n", config.cpu_active);	116	printf("cpus:%d\n", config.cpu_active);
116		117
117	if (config.cpu_active >1) {	118	if (config.cpu_active >1) {
118	second_thread = thread_create(&running_tasklet, NULL, TASK, THREAD_FLAG_WIRED,"running tasklet", false);	119	second_thread = thread_create(&running_tasklet, NULL, TASK, THREAD_FLAG_WIRED,"running tasklet", false);
119	if (CPU->id == 0)	120	if (CPU->id == 0)
120	second_thread->cpu = &cpus[1];	121	second_thread->cpu = &cpus[1];
121	else	122	else
122	second_thread->cpu = &cpus[0];	123	second_thread->cpu = &cpus[0];
123	thread_ready(second_thread);	124	thread_ready(second_thread);
124	}	125	}
125	#endif	126	#endif
126		127
127	//before we start we need to register a tasklet	128	//before we start we need to register a tasklet
128	if (!quiet)	129	if (!quiet)
129	printf("cpu:%d, Registering tasklet...", CPU->id);	130	printf("cpu:%d, Registering tasklet...", CPU->id);
130	if (!quiet)	131	if (!quiet)
131	tasklet_desc=tasklet_register(&func, "\nTasklet called and received data\n");	132	tasklet_desc=tasklet_register(&func, "\nTasklet called and received data\n");
132	else	133	else
133	tasklet_desc=tasklet_register(&func, "");	134	tasklet_desc=tasklet_register(&func, "");
134	if (!quiet)	135	if (!quiet)
135	printf("Done!\n");	136	printf("Done!\n");
136		137
137	//first we'll try disabling the tasklet	138	//first we'll try disabling the tasklet
138	if (!quiet)	139	if (!quiet)
139	printf("cpu:%d, Disabling tasklet...", CPU->id);	140	printf("cpu:%d, Disabling tasklet...", CPU->id);
140	tasklet_disable(tasklet_desc);	141	tasklet_disable(tasklet_desc);
141	if (!quiet)	142	if (!quiet)
142	printf("Done!\n");	143	printf("Done!\n");
143		144
144	//we'll schedule the disabled tasklet	145	//we'll schedule the disabled tasklet
145	if (!quiet)	146	if (!quiet)
146	printf("cpu:%d, Scheduling tasklet...", CPU->id);	147	printf("cpu:%d, Scheduling tasklet...", CPU->id);
147	tasklet_schedule(tasklet_desc);	148	tasklet_schedule(tasklet_desc);
148	if (!quiet)	149	if (!quiet)
149	printf("Done!\n");	150	printf("Done!\n");
150		151
151	//and we'll wait if it gets called. It shouldn't however, because it's disabled	152	//and we'll wait if it gets called. It shouldn't however, because it's disabled
152	if (!quiet)	153	if (!quiet)
153	printf("cpu:%d, Waiting 1s...\n", CPU->id);	154	printf("cpu:%d, Waiting 1s...\n", CPU->id);
154	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);	155	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
155	if (!quiet)	156	if (!quiet)
156	printf("cpu:%d, Done!\n", CPU->id);	157	printf("cpu:%d, Done!\n", CPU->id);
157		158
158		159
159	//then we'll try to enable it	160	//then we'll try to enable it
160	if (!quiet)	161	if (!quiet)
161	printf("cpu:%d, Enabling tasklet...", CPU->id);	162	printf("cpu:%d, Enabling tasklet...", CPU->id);
162	tasklet_enable(tasklet_desc);	163	tasklet_enable(tasklet_desc);
163	if (!quiet)	164	if (!quiet)
164	printf("Done!\n");	165	printf("Done!\n");
165		166
166	//and wait if it gets called this time. It should because it's enabled	167	//and wait if it gets called this time. It should because it's enabled
167	if (!quiet)	168	if (!quiet)
168	printf("cpu:%d, Waiting 1s...\n", CPU->id);	169	printf("cpu:%d, Waiting 1s...\n", CPU->id);
169	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);	170	waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
170	if (!quiet)	171	if (!quiet)
171	printf("cpu:%d, Done!\n", CPU->id);	172	printf("cpu:%d, Done!\n", CPU->id);
172	#ifdef CONFIG_SMP	173	#ifdef CONFIG_SMP
173	if (config.cpu_active >1) {	174	if (config.cpu_active >1) {
174	printf("Joining with the second thread...");	175	printf("Joining with the second thread...");
175	thread_join(second_thread);	176	thread_join(second_thread);
176	printf("Done\n");	177	printf("Done\n");
177	}	178	}
178		179
179	#endif	180	#endif
180	//finally we'll free the tasklet structure	181	//finally we'll free the tasklet structure
181	if (!quiet)	182	if (!quiet)
182	printf("cpu:%d, Freeing...", CPU->id);	183	printf("cpu:%d, Freeing...", CPU->id);
183	tasklet_free(tasklet_desc);	184	tasklet_free(tasklet_desc);
184	if (!quiet)	185	if (!quiet)
185	printf("Done!\n");	186	printf("Done!\n");
186		187
187		188
188	return NULL;	189	return NULL;
189	}	190	}
190		191

Subversion Repositories HelenOS

(root)/branches/rcu/kernel/test/tasklet/tasklet1.c – Rev 2292 → 2307