sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

sched/wqueue: merge kwork_lpthread.c and kwork_hpthread.c to kwork_thread.c

Browse Source 
Signed-off-by: Jiuzhu Dong <dongjiuzhu1@xiaomi.com>
This commit is contained in:
Jiuzhu Dong 2021-06-25 14:24:45 +08:00 committed by Xiang Xiao
parent bb63afde1e
commit a0c3a0923a
4 changed files with 121 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
sched/wqueue/Make.defs
View File

@ -23,21 +23,11 @@
ifeq ($(CONFIG_SCHED_WORKQUEUE),y)
CSRCS += kwork_queue.c kwork_process.c kwork_cancel.c kwork_signal.c
CSRCS += kwork_thread.c
# Add high priority work queue files
ifeq ($(CONFIG_SCHED_HPWORK),y)
CSRCS += kwork_hpthread.c
endif
# Add low priority work queue files
ifeq ($(CONFIG_SCHED_LPWORK),y)
CSRCS += kwork_lpthread.c
ifeq ($(CONFIG_PRIORITY_INHERITANCE),y)
CSRCS += kwork_inherit.c
endif # CONFIG_PRIORITY_INHERITANCE
endif # CONFIG_SCHED_LPWORK
# Add work queue notifier support

171
sched/wqueue/kwork_lpthread.c
View File

@ -1,171 +0,0 @@
/****************************************************************************
* sched/wqueue/kwork_lpthread.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <unistd.h>
#include <sched.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <queue.h>
#include <debug.h>
#include <nuttx/wqueue.h>
#include <nuttx/kthread.h>
#include <nuttx/kmalloc.h>
#include <nuttx/clock.h>
#include "wqueue/wqueue.h"
#ifdef CONFIG_SCHED_LPWORK
/****************************************************************************
* Public Data
****************************************************************************/
/* The state of the kernel mode, low priority work queue(s). */
struct lp_wqueue_s g_lpwork;
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: work_lpthread
*
* Description:
* These are the worker thread(s) that performs the actions placed on the
* low priority work queue.
*
* These, along with the higher priority worker thread are the kernel mode
* work queues (also build in the flat build).
*
* All kernel mode worker threads are started by the OS during normal
* bring up. This entry point is referenced by OS internally and should
* not be accessed by application logic.
*
* Input Parameters:
* argc, argv (not used)
*
* Returned Value:
* Does not return
*
****************************************************************************/
static int work_lpthread(int argc, char *argv[])
{
int wndx = 0;
#if CONFIG_SCHED_LPNTHREADS > 1
pid_t me = getpid();
int i;
/* Find out thread index by search the workers in g_lpwork */
for (wndx = 0, i = 0; i < CONFIG_SCHED_LPNTHREADS; i++)
{
if (g_lpwork.worker[i].pid == me)
{
wndx = i;
break;
}
}
DEBUGASSERT(i < CONFIG_SCHED_LPNTHREADS);
#endif
/* Loop forever */
for (; ; )
{
/* Then process queued work. work_process will not return until:
* (1) there is no further work in the work queue, and (2) signal is
* triggered, or delayed work expires.
*/
work_process((FAR struct kwork_wqueue_s *)&g_lpwork, wndx);
}
return OK; /* To keep some compilers happy */
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: work_start_lowpri
*
* Description:
* Start the low-priority, kernel-mode worker thread(s)
*
* Input Parameters:
* None
*
* Returned Value:
* The task ID of the worker thread is returned on success. A negated
* errno value is returned on failure.
*
****************************************************************************/
int work_start_lowpri(void)
{
pid_t pid;
int wndx;
/* Don't permit any of the threads to run until we have fully initialized
* g_lpwork.
*/
sched_lock();
/* Start the low-priority, kernel mode worker thread(s) */
sinfo("Starting low-priority kernel worker thread(s)\n");
for (wndx = 0; wndx < CONFIG_SCHED_LPNTHREADS; wndx++)
{
pid = kthread_create(LPWORKNAME, CONFIG_SCHED_LPWORKPRIORITY,
CONFIG_SCHED_LPWORKSTACKSIZE,
(main_t)work_lpthread,
(FAR char * const *)NULL);
DEBUGASSERT(pid > 0);
if (pid < 0)
{
serr("ERROR: kthread_create %d failed: %d\n", wndx, (int)pid);
sched_unlock();
return (int)pid;
}
g_lpwork.worker[wndx].pid = pid;
g_lpwork.worker[wndx].busy = true;
}
sched_unlock();
return g_lpwork.worker[0].pid;
}
#endif /* CONFIG_SCHED_LPWORK */

1
sched/wqueue/kwork_notifier.c
View File

@ -33,7 +33,6 @@
#include <assert.h>
#include <nuttx/kmalloc.h>
#include <nuttx/semaphore.h>
#include <nuttx/wqueue.h>
#include "wqueue/wqueue.h"

175
sched/wqueue/kwork_hpthread.c → sched/wqueue/kwork_thread.c
View File

@ -1,5 +1,5 @@
/****************************************************************************
* sched/wqueue/kwork_hpthread.c
* sched/wqueue/kwork_thread.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@ -26,7 +26,9 @@
#include <unistd.h>
#include <sched.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <queue.h>
@ -34,27 +36,33 @@
#include <nuttx/wqueue.h>
#include <nuttx/kthread.h>
#include <nuttx/kmalloc.h>
#include <nuttx/clock.h>
#include "wqueue/wqueue.h"
#ifdef CONFIG_SCHED_HPWORK
#if defined(CONFIG_SCHED_WORKQUEUE)
/****************************************************************************
* Public Data
****************************************************************************/
#if defined(CONFIG_SCHED_HPWORK)
/* The state of the kernel mode, high priority work queue(s). */
struct hp_wqueue_s g_hpwork;
#endif /* CONFIG_SCHED_HPWORK */
#if defined(CONFIG_SCHED_LPWORK)
/* The state of the kernel mode, low priority work queue(s). */
struct lp_wqueue_s g_lpwork;
#endif /* CONFIG_SCHED_LPWORK */
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: work_hpthread
* Name: work_thread
*
* Description:
* These are the worker threads that performs the actions placed on the
@ -75,26 +83,14 @@ struct hp_wqueue_s g_hpwork;
*
****************************************************************************/
static int work_hpthread(int argc, char *argv[])
static int work_thread(int argc, char *argv[])
{
int wndx = 0;
#if CONFIG_SCHED_HPNTHREADS > 1
pid_t me = getpid();
int i;
FAR struct kwork_wqueue_s *queue;
int wndx;
/* Find out thread index by search the workers in g_hpwork */
for (wndx = 0, i = 0; i < CONFIG_SCHED_HPNTHREADS; i++)
{
if (g_hpwork.worker[i].pid == me)
{
wndx = i;
break;
}
}
DEBUGASSERT(i < CONFIG_SCHED_HPNTHREADS);
#endif
queue = (FAR struct kwork_wqueue_s *)
((uintptr_t)strtoul(argv[1], NULL, 0));
wndx = atoi(argv[2]);
/* Loop forever */
@ -105,12 +101,76 @@ static int work_hpthread(int argc, char *argv[])
* triggered, or delayed work expires.
*/
work_process((FAR struct kwork_wqueue_s *)&g_hpwork, wndx);
work_process(queue, wndx);
}
return OK; /* To keep some compilers happy */
}
/****************************************************************************
* Name: work_thread_create
*
* Description:
* This function creates and activates a work thread task with kernel-
* mode privileges.
*
* Input Parameters:
* name - Name of the new task
* priority - Priority of the new task
* stack_size - size (in bytes) of the stack needed
* nthread - Number of work thread should be created
* wqueue - Work queue instance
*
* Returned Value:
* A negated errno value is returned on failure.
*
****************************************************************************/
static int work_thread_create(FAR const char *name, int priority,
int stack_size, int nthread,
FAR struct kwork_wqueue_s *wqueue)
{
FAR char *argv[3];
char args[2][16];
int wndx;
int pid;
snprintf(args[0], 16, "0x%" PRIxPTR, (uintptr_t)wqueue);
argv[0] = args[0];
argv[2] = NULL;
/* Don't permit any of the threads to run until we have fully initialized
* g_hpwork and g_lpwork.
*/
sched_lock();
for (wndx = 0; wndx < nthread; wndx++)
{
snprintf(args[1], 16, "%d", wndx);
argv[1] = args[1];
pid = kthread_create(name, priority, stack_size,
(main_t)work_thread, argv);
DEBUGASSERT(pid > 0);
if (pid < 0)
{
serr("ERROR: work_thread_create %d failed: %d\n", wndx, pid);
sched_unlock();
return pid;
}
#ifdef CONFIG_PRIORITY_INHERITANCE
wqueue->worker[wndx].pid = pid;
#endif
wqueue->worker[wndx].busy = true;
}
sched_unlock();
return OK;
}
/****************************************************************************
* Public Functions
****************************************************************************/
@ -125,47 +185,50 @@ static int work_hpthread(int argc, char *argv[])
* None
*
* Returned Value:
* The task ID of the worker thread is returned on success. A negated
* errno value is returned on failure.
* A negated errno value is returned on failure.
*
****************************************************************************/
#if defined(CONFIG_SCHED_HPWORK)
int work_start_highpri(void)
{
pid_t pid;
int wndx;
/* Don't permit any of the threads to run until we have fully initialized
* g_hpwork.
*/
sched_lock();
/* Start the high-priority, kernel mode worker thread(s) */
sinfo("Starting high-priority kernel worker thread(s)\n");
for (wndx = 0; wndx < CONFIG_SCHED_HPNTHREADS; wndx++)
{
pid = kthread_create(HPWORKNAME, CONFIG_SCHED_HPWORKPRIORITY,
return work_thread_create(HPWORKNAME, CONFIG_SCHED_HPWORKPRIORITY,
CONFIG_SCHED_HPWORKSTACKSIZE,
(main_t)work_hpthread,
(FAR char * const *)NULL);
DEBUGASSERT(pid > 0);
if (pid < 0)
{
serr("ERROR: kthread_create %d failed: %d\n", wndx, (int)pid);
sched_unlock();
return (int)pid;
CONFIG_SCHED_HPNTHREADS,
(FAR struct kwork_wqueue_s *)&g_hpwork);
}
g_hpwork.worker[wndx].pid = pid;
g_hpwork.worker[wndx].busy = true;
}
sched_unlock();
return g_hpwork.worker[0].pid;
}
#endif /* CONFIG_SCHED_HPWORK */
/****************************************************************************
* Name: work_start_lowpri
*
* Description:
* Start the low-priority, kernel-mode worker thread(s)
*
* Input Parameters:
* None
*
* Returned Value:
* A negated errno value is returned on failure.
*
****************************************************************************/
#if defined(CONFIG_SCHED_LPWORK)
int work_start_lowpri(void)
{
/* Start the low-priority, kernel mode worker thread(s) */
sinfo("Starting low-priority kernel worker thread(s)\n");
return work_thread_create(LPWORKNAME, CONFIG_SCHED_LPWORKPRIORITY,
CONFIG_SCHED_LPWORKSTACKSIZE,
CONFIG_SCHED_LPNTHREADS,
(FAR struct kwork_wqueue_s *)&g_lpwork);
}
#endif /* CONFIG_SCHED_LPWORK */
#endif /* CONFIG_SCHED_WORKQUEUE */