Free threading bugs software for linux

RT-Thread is a real-time operating system. It is designed specifically for small memory footprint platforms. The kernel supports the tranditional RTOS services, such as multiple threads, semaphores, mutexes, event flags, mailboxes, etc.
RT-Thread project also provides a C-expression interpreter shell, from which a programmer can access kernel variables and invoke system functions.
Main features:
Kernel Object System
- There is a kernel object system, which can access and manage all of the kernel objects. Kernel objects include most of the facilities in the kernel, for example, thread, semaphore etc. Kernel objects can be static objects, whose memory is allocated in compiling. It can be dynamic objects as well, whose memory is allocated from system heaps in runtime. Through the kernel object system, RT-Thread operating system can be independent from the memory management system and greatly enhance the scalability of the system.
Multi-Task/Thread Scheduling
- RT-Thread operating system supports multi-task systems, which are based on thread scheduling. The scheduling algorithm used in RT-Thread operating system is a full preemptive priority-based scheduling algorithm. It supports 256 priority levels, in which 0 is the highest and 255 the lowest. The 255th priority is used for idle thread. The scheduling algorithm also supports threads running at same priority level. The shared time-slice round-robin scheduling is used for this case. The time of scheduler to determine the next highest ready thread is determinant. The number of threads in the system is unlimited, only related with RAM.
Synchronization Mechanisms
- RT-Thread operating system supports the traditional semaphore and mutex. Mutex objects use inherited priority to prevent priority reversion. The semaphore release action is safe for interrupt service routine. Moreover, the block queue for thread to obtain semaphore or mutex can be sorted by priority or FIFO.
Inter-Thread Communication
- RT-Thread operating systems supports event/fast event, mail box and message queue. The event mechanism is used to awake a thead by setting one or more corresponding bit of a binary number when an event ocurs. The fast event supports event thread queue. Once a one bit event occurs, the corresponding blocked thread can be found out timing accurately, then will be waked up. In mailbox, a mail length is fixed to 4 byte, which is more effective than message queue. The send action for communication facilities is also safe for interrupt service routine.
Clock and Timer
- In default, the system uses clock tick to implement shared time-slice scheduling. The timing sensitivity of thread is implemented by timers. The timer can be set as one-shot or periodic timeout.
Memory Management
- RT-Thread operating system supports two types memory management: static memory pool management and dynamic memory heap management. The time to allocate a memory block from the memory pool is determinant and when the memory pool is empty, the allocated thread can be blocked (or immediately return, or waiting for sometime to return, which are determined by a timeout parameter). When other thread releases memory blocks to this memory pool, the blocked thread is wake up.
Enhancements:
- More porting was done to Samsung S3C44b0 CPU, AMTEL AT91SAM7S64, Nintendo DS, and Intel i386.

State Threads project is a small library for designing scalable Internet applications.
The State Threads is a small application library which provides a foundation for writing fast and highly scalable Internet applications (such as Web servers, proxy servers, mail transfer agents, etc.) on UNIX-like platforms.
It offers a threading API for structuring a network application as an event-driven state machine.
The State Threads library is a derivative of the Netscape Portable Runtime library (NSPR) and therefore is distributed under the Mozilla Public License (MPL) version 1.1 or the GNU General Public License (GPL) version 2 or later.
Enhancements:
- Added support for kqueue and epoll on platforms that support them.
- Added ability to choose the event notification system at program startup.
- Long-overdue public definitions of ST_UTIME_NO_TIMEOUT (-1ULL) and ST_UTIME_NO_WAIT (0) [bug 1514436].
- Documentation patch for st_utime() [bug 1514484].
- Documentation patch for st_timecache_set() [bug 1514486].
- Documentation patch for st_netfd_serialize_accept() [bug 1514494].
- Added st_writev_resid() [rfe 1538344].
- Added st_readv_resid() [rfe 1538768] and, for symmetry, st_readv().

Threads-pop3d provides a very fast and light THREADS POP3 Daemon which can work with MySQL.

THREADS POP is an implementation of the Post Office Protocol server that conforms fully to the specifications in RFC 1939 (and later ones). For start/stop use /etc/rc.d/init.d/threads-pop3d.init script.

After start THREADS POP uses syslogd to log all messages. If you will have some problems look in the file /var/log/mail.log. This daemon first print there information about started threads. Later you can see information about logged users. If you end work (dont forget about threads-pop3d.init script) you will see how many connections served everyone thread.

The extra one thread show you how many connections daemon needed create for surplus. I.e. your daemon goes with 10 threads. In the one time connect themself 10 clients.

Then server creates next threads to serve next clients. Now every extra client (connected in this same time) increases surpluses counter. After disconnection stays so many children as you gave in -c option. In the one time server cant overdraft MAX_CHILDREN number.

If he does, then next clients must wait for disconnection the connected one.

DM1 Thread Library is part of the DM1 project. This library was born out of my need to have a portable C++ Thread library that would be simple to use, and would provide all the necessary Threads functionality I required for the DM1 project.
Initially, this library was in C, but when I decided to re-write DM1 in C++, I ported the library to C++. During the port, I enhanced the functionality of the Threads library.
The DM1 Threads library aims to be small. It does not try to provide a comprehensive set of functionality, but only what is absolutely essential for a project like DM1. I had the simplicity of the Java Threads package in mind when creating this library.
The constructs provided by the DM1 Thread library are:
- Thread objects that represent Operating System threads.
- A Mutex is provided as a mechanism for Mutual Exclusion . Mutexes are used to ensure that a piece of code is executed by only one thread at any point in time.
- Events are provided as low-level mechanisms for thread synchronisation. Events can be waited for, and signalled to.
- A higher level object, that combines the functionality of an Event and a Mutex, is provided. This is the Monitor object. A Monitor can be locked exclusively, just like a Mutex, but it can also be made the object of a Wait operation. The signalling mechanism supports notification of one or more waiting threads.
- To enable more efficient locking when both shared and exclusive access to data is required, Latches are provided.
- Apart from the Thread synchronisation primitives described above, the library also provides a ThreadPool for the situation when it is inefficient to create a thread exclusively for a particular task, and it is desirable to share a pool of threads for executing multiple tasks.
Design Principles
The DM1 Threads library was designed with the following principles in mind:
1. Implement the bare minimum that is required. This Threads library does not aim to be a comprehensive threads package.
2. Avoid complex algorithms. If a particular construct is hard to implement correctly on all platforms, avoid it.
3. Document the library.
4. Avoid low level code, such as assembler code to implement Spin locks. Rely on the libraries provided by the Operating System.
5. Avoid holding Mutexes beyond function calls. A DM1 Thread library function will not hold any Mutex locks when it returns.
6. Avoid using clever C++ techniques wherever possible. (Unfortunately, some cleverness is required to implement the Thread class correctly).
7. Avoid dependency on external libraries. The DM1 library only requires the standard C library, apart from native Threads functionality.
8. Always report an error as soon as it is discovered.
9. Insert debug messages that can be switched on at run-time.
10. Do not throw exceptions from destructors because these might be executing as a result of an uncaught exception.
11. Never let an error go unreported.

Thread Safe Template Library (TSTL) is a C++ library that provides thread-safe storage data structures without global locking. The library includes classes for maps based on a non-binary extensible hashing tree for very fast access, a pipe, a timercache, and a fast writer multiple reader guard without global locking (which uses the interlocked Intel instruction set).
Enhancements:
- Porting for x64 AMD, Intel, and MSVC 8.0.
- A new cache template with policy by element number.
- Access to elements has been implemented via a map template.
- The adding policy in the timer cache template has been changed.
- The string hash routine has been optimized.
- The timings in the nbmap.h template have changed.

FreeBSD is an advanced operating system for x86 compatible (including Pentium and Athlon), amd64 compatible (including Opteron, Athlon 64, and EM64T), IA-64, PC-98, Alpha/AXP and UltraSPARC architectures.
It is derived from BSD, the version of UNIX developed at the University of California, Berkeley. It is developed and maintained by a large team of individuals. Additional platforms are in various stages of development.
FreeBSD offers advanced networking, performance, security and compatibility features today which are still missing in other operating systems, even some of the best commercial ones.
FreeBSD makes an ideal Internet or Intranet server. It provides robust network services under the heaviest loads and uses memory efficiently to maintain good response times for thousands of simultaneous user processes.
The quality of FreeBSD combined with todays low-cost, high-speed PC hardware makes FreeBSD a very economical alternative to commercial UNIX workstations. It is well-suited for a great number of both desktop and server applications.
FreeBSD can be installed from a variety of media including CD-ROM, DVD-ROM, floppy disk, magnetic tape, an MS-DOS partition, or if you have a network connection, you can install it directly over anonymous FTP or NFS.
While you might expect an operating system with these features to sell for a high price, FreeBSD is available free of charge and comes with full source code.
It is easy to contribute to FreeBSD. All you need to do is find a part of FreeBSD which you think could be improved and make those changes (carefully and cleanly) and submit that back to the Project by means of send-pr or a committer, if you know one. This could be anything from documentation to artwork to source code.
Even if you are not a programmer, there are other ways to contribute to FreeBSD. The FreeBSD Foundation is a non-profit organization for which direct contributions are fully tax deductible.
Main features:
- A merged virtual memory and filesystem buffer cache continuously tunes the amount of memory used for programs and the disk cache. As a result, programs receive both excellent memory management and high performance disk access, and the system administrator is freed from the task of tuning cache sizes.
- Compatibility modules enable programs for other operating systems to run on FreeBSD, including programs for Linux, SCO UNIX, and System V Release 4.
- Soft Updates allows improved filesystem performance without sacrificing safety and reliability. It analyzes meta-data filesystem operations to avoid having to perform all of those operations synchronously. Instead, it maintains internal state about pending meta-data operations and uses this information to cache meta-data, rewrite meta-data operations to combine subsequent operations on the same files, and reorder meta-data operations so that they may be processed more efficiently. Features such as background filesystem checking and file system snapshots are built on the consistency and performance foundations of soft updates.
- File system snapshots, permitting administrators to take atomic file system snapshots for backup purposes using the free space in the file system, as well as facilitating background fsck, which allows the system to reach multiuser mode without waiting on file system cleanup operations following power outages.
- Support for IP Security (IPsec) allows improved security in networks, and support for the next-generation Internet Protocol, IPv6. The FreeBSD IPSEC implementation includes support for a broad range of accelerated crypto hardware.
- Out of the box support for IPv6 via the KAME IPv6 stack allows FreeBSD to be seamlessly integrated into next generation networking environments. FreeBSD even ships with many applications extended to support IPv6!
- Multi-threaded SMP architecture capable of executing the kernel in parallel on multiple processors, and with kernel preemption, allowing high priority kernel tasks to preempt other kernel activity, reducing latency. This includes a multi-threaded network stack and a multi-threaded virtual memory subsystem. With FreeBSD 6.x, support for a fully parallel VFS allows the UFS file system to run on multiple processors simultaneously, permitting load sharing of CPU-intensive I/O optimization.
- M:N application threading via pthreads permitting threads to execute on multiple CPUs in a scaleable manner, mapping many user threads onto a small number of Kernel Schedulable Entities. By adopting the Scheduler Activation model, the threading approach can be adapted to the specific requirements of a broad range of applications.
- Netgraph pluggable network stack allows developers to dynamically and easily extend the network stack through clean layered network abstractions. Netgraph nodes can implement a broad range of new network services, including encapsulation, tunneling, encryption, and performance adaptation. As a result, rapid prototyping and production deployment of enhanced network services can be performed far more easily and with fewer bugs.
- TrustedBSD MAC Framework extensible kernel security, which allows developers to customize the operating system security model for specific environments, from creating hardening policies to deploying mandatory labeled confidentiality of integrity policies. Sample seucrity policies include Multi-Level Security (MLS), and Biba Integrity Protection. Third party modules include SEBSD, a FLASK-based implementation of Type Enforcement.
- GEOM pluggable storage layer, which permits new storage services to be quickly developed and cleanly integrated into the FreeBSD storage subsystem. GEOM provides a consistent and coherrent model for discovering and layering storage services, making it possible to layer services such as RAID and volume management easily.
- FreeBSDs GEOM-Based Disk Encryption (GBDE), provides strong cryptographic protection using the GEOM Framework, and can protect file systems, swap devices, and other use of storage media.
- Kernel Queues allow programs to respond more efficiently to a variety of asynchronous events including file and socket IO, improving application and system performance.
- Accept Filters allow connection-intensive applications, such as web servers, to cleanly push part of their functionality into the operating system kernel, improving performance.

POE::Component::Pool::Thread is a POE Managed Boss/Worker threadpool.

SYNOPSIS

use POE qw( Component::Pool::Thread );

POE::Component::Pool::Thread->new
( MinFree => 2,
MaxFree => 5,
MaxThreads => 15,
StartThrneads => 5,
Name => "ThreadPool",
EntryPoint => &thread_entry_point,
CallBack => &result_handler,
inline_states => {
_start => sub {
my ($kernel, $heap) = @_[ KERNEL, HEAP ];

# We are inside the component session
$kernel->yield(run => @arguements);

$kernel->post(ThreadPool => run => @arguements);
},
}
);

sub thread_entry_point {
my (@arguements) = @_;

return 1;
}

sub result_handler {
my ($kernel, $result) = @_[ KERNEL, ARG0 ];

$result == 1;
}

This is an expand-on-demand thread pool managed through a POE session in a manner that does not interfer with cooperative multitasking. A single pipe is created, each thread communicates its state to the main process through this pipe. No serialization occurs (these are threads, not child processes), so execution is very fast.