Hello Joel,
On 09/07/15 00:46, Joel Sherrill wrote:
Hi
I noticed the modification to qoriq_t2080rdb.cfg and wondered
how things were going. How many cores have you all seen running?
We use all 24 cores, the roadmap for this platform is 64 cores.
Any scaling issues?
Yes, there is a lot of work ahead. I work currently on optimized OpenMP
support. Here we have the same problems that we already observed with
the new network stack on SMP. The Classic API object identifier to
object translation is a performance problem. The object creation is a
major bottleneck (mainly due to the use of the allocator mutex) for
OpenMP which dynamically creates objects.
I have a prototype implementation for self-contained objects which may
be used for the locks etc. in Newlib, GCC and the network stack (see
attached file), but this is something for post 4.11.
On the positive side is the low level stuff, the scheduler and thread
dispatching works really well.
--
Sebastian Huber, embedded brains GmbH
Address : Dornierstr. 4, D-82178 Puchheim, Germany
Phone : +49 89 189 47 41-16
Fax : +49 89 189 47 41-09
E-Mail : sebastian.hu...@embedded-brains.de
PGP : Public key available on request.
Diese Nachricht ist keine geschäftliche Mitteilung im Sinne des EHUG.
/*
* Copyright (c) 2015 embedded brains GmbH. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "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 COPYRIGHT
* OWNER OR CONTRIBUTORS 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.
*/
#ifndef _SYS_LOCK_H_
#define _SYS_LOCK_H_
#include <sys/cdefs.h>
__BEGIN_DECLS
struct _Thread_Control;
struct _Thread_queue_Heads;
struct _Ticket_lock_Control {
unsigned int _next_ticket;
unsigned int _now_serving;
};
struct _Thread_queue_Queue {
struct _Thread_queue_Heads *_heads;
struct _Ticket_lock_Control _Lock;
};
struct _Mutex_Control {
struct _Thread_queue_Queue _Queue;
struct _Thread_Control *_owner;
};
struct _Mutex_recursive_Control {
struct _Mutex_Control _Mutex;
unsigned int _nest_level;
};
struct _Semaphore_Control {
struct _Thread_queue_Queue _Queue;
unsigned int _count;
};
#define _MUTEX_INITIALIZER { { 0, { 0, 0 } }, 0 }
#define _MUTEX_RECURSIVE_INITIALIZER { _MUTEX_INITIALIZER, 0 }
#define _SEMAPHORE_INITIALIZER(_count) { { 0, { 0, 0 } }, _count }
static inline void
_Mutex_Initialize(struct _Mutex_Control *_mutex)
{
struct _Mutex_Control _init = _MUTEX_INITIALIZER;
*_mutex = _init;
}
void _Mutex_Acquire(struct _Mutex_Control *);
int _Mutex_Try_acquire(struct _Mutex_Control *);
void _Mutex_Release(struct _Mutex_Control *);
static inline void
_Mutex_Destroy(struct _Mutex_Control *_mutex)
{
(void)_mutex;
}
static inline void
_Mutex_recursive_Initialize(struct _Mutex_recursive_Control *_mutex)
{
struct _Mutex_recursive_Control _init = _MUTEX_RECURSIVE_INITIALIZER;
*_mutex = _init;
}
void _Mutex_recursive_Acquire(struct _Mutex_recursive_Control *);
int _Mutex_recursive_Try_acquire(struct _Mutex_recursive_Control *);
void _Mutex_recursive_Release(struct _Mutex_recursive_Control *);
static inline void
_Mutex_recursive_Destroy(struct _Mutex_recursive_Control *_mutex)
{
(void)_mutex;
}
static inline void
_Semaphore_Initialize(struct _Semaphore_Control *_semaphore,
unsigned int _count)
{
struct _Semaphore_Control _init = _SEMAPHORE_INITIALIZER(_count);
*_semaphore = _init;
}
void _Semaphore_Wait(struct _Semaphore_Control *);
void _Semaphore_Post(struct _Semaphore_Control *);
static inline void
_Semaphore_Destroy(struct _Semaphore_Control *_semaphore)
{
(void)_semaphore;
}
typedef struct _Mutex_Control _LOCK_T;
typedef struct _Mutex_recursive_Control _LOCK_RECURSIVE_T;
#define __LOCK_INIT(_qualifier, _designator) \
_qualifier _LOCK_T _designator = _MUTEX_INITIALIZER
#define __LOCK_INIT_RECURSIVE(_qualifier, _designator) \
_qualifier _LOCK_T _designator = _MUTEX_RECURSIVE_INITIALIZER
#define __lock_init(_lock) _Mutex_Initialize(&_lock)
#define __lock_acquire(_lock) _Mutex_Acquire(&_lock)
#define __lock_try_acquire(lock) _Mutex_Try_acquire(&_lock)
#define __lock_release(_lock) _Mutex_Release(&_lock)
#define __lock_close(_lock) _Mutex_Destroy(&_lock)
#define __lock_init_recursive(_lock) _Mutex_recursive_Initialize(&_lock)
#define __lock_acquire_recursive(_lock) _Mutex_recursive_Acquire(&_lock)
#define __lock_try_acquire_recursive(lock) _Mutex_recursive_Try_acquire(&_lock)
#define __lock_release_recursive(_lock) _Mutex_recursive_Release(&_lock)
#define __lock_close_recursive(_lock) _Mutex_recursive_Destroy(&_lock)
__END_DECLS
#endif /* _SYS_LOCK_H_ */
_______________________________________________
devel mailing list
devel@rtems.org
http://lists.rtems.org/mailman/listinfo/devel
