Baigudin Software avatar
Baigudin Software logo
ru region
en region


The real-time object-oriented operating kernel is written in C++ programming language for small embedded systems.

PHP DOM Builder

The library is written in PHP programming language for generating valid HTML documents and operating those.

Baigudin Software successfully starts in Kaspersky Start program

Baigudin Software has been successfully started in Kaspersky Start program by Kaspersky Lab and performs the BOOS Core operating kernel to it.

BOOS Core for Texas Instruments TMS320C64x Digital Signal Processors family is released

Date: 2016.08.10

Baigudin Software project has represented BOOS Core, which is an operating kernel, for TMS320C64x Digital Signal Processors family of Texas Instruments Company with single core. The kernel is written in C++ programming language with ISO/IEC 14882:1998 standard and built using object-oriented programming with a root class of core class hierarchy. The kernel has a hardware independent application program interface which allows porting source codes of applications to another TMS320C64x DSPs easily.

Why BOOS Core

BOOS Core is designed for high-loaded applications, which may be executed in multi-threads environment and require real-time scheduling. Including source code and data, a total size of the core, which depends on using compilers and linkers, is less than 100 KB. It allows using BOOS Core within processors with limited physical memory. The core is fully independent of any external libraries and realizes an initialization of hardware modules and initialized data sections which were created by a compiler. Integrated algorithms for working with heap memory, hardware controlling, dynamical allocation of core resources such as threads, semaphores, interrupts, etc make convenient ways for creating new applications, which can be easily ported to another devices, by using BOOS Core and its hardware independent API.

The following list shows primary features of BOOS Core:

  • Is written in C++ programming language with ISO/IEC 14882:1998 standard.
  • Initializes processor units.
  • Initializes initialized data sections.
  • Calls constructors of global objects.
  • Uses an integrated heap memory manager for allocating objects and resources of the system.
  • Controls allocated resources.
  • Has flexible configuration for configuring the kernel.
  • Is independent of any external libraries.

Thus, a developer needs to implement a main method of Main class and the simplest program has been done.

The simplest program with BOOS Core

The core is based on objects which implement some logical or hardware functions of a system. All objects are grouped into the groups which are libraries. Each library is described in self namespace. These libraries or object files, which were compiled from source codes of each library, and user application object files have to be linked by Linker. The linked result is executable file of a program (see the picture below).

BOOS Core executable file building

The simplest program is a program which does no things, but is compiled and linked successfully. Here is an example:

 * User main class.
 * @author    Sergey Baigudin
 * @copyright Sergey Baigudin, BAIGUDIN SOFTWARE, 2016
 * @license
 * @link
#include "boos.Main.hpp"

 * User method which will be stated as first.
 * @param argc count of array elements.
 * @param argv array of arguments.
 * @return error code or zero.

int Main::main(int argccharargv[])
// The simplest application which does some things and does no things
return argc && argv != NULL 0;

Thus, all necessary steps for creating the simplest program by using BOOS Core are to create a file, which we usually name boos.Main.cpp, and add this file with the core libraries and RTS library to a project. One worth noting, RTS library by Texas Instruments Company is used for accessing to standard C++ language operators such as dividing or multiplying long number.

BOOS Core and user application

The BOOS Core operating kernel is designed for Single Core Digital Signal Processors of Texas Instruments and allows to design multi-threads user applications by using time slices for executing threads. The following figure shows an example of threads scheduling for an abstract user application.

BOOS Core threads scheduling

When the kernel gets a control, it initializes processor hardware units and self internal data structures, calls global class constructors, captures required resources, saves self context, creates the main user thread, and starts to execute that. When the main thread has been called to execution, the kernel execution is stopped until all user threads, including main thread, will be completed. When threads execution are wholly completed, saved kernel context will be restored and the kernel will make a deinitialization and go to idle state.

An entry point of user application is main method. An application, which has obtained a controlling, fully uses all processor time and can capture some resources of the kernel until which can be allocated in heap or stack memory. All threads of an application are being executed in one process within total data memory. Thus, every thread gets unique addressable stack memory and common heap memory. The following figure shows the state machine of executing thread.

BOOS Core thread state machine

You may see that completed thread is not deleted by the kernel but jumps to DEAD state. It means the stack and all allocated objects of dead thread are being presented in memory if a developer of application does not delete created resources. Therefore, data memory of an application should be controlled by developers.

Thus, an abstract user application creates two more threads which will be completed when those functions have been executed. So, completed thread is deleted by thread which has created that, and this is the primary rule: if someone creates something, this someone must delete that. This recommendation is valid for all objects of the system. Accordingly, parent thread always has to be alive more time than its children.

Resuming, we note that BOOS Core has been developed for making development process of user applications easily and promptly. So, applications with BOOS Core can be implemented by using any algorithmic ways without deep knowledge of DSP architectures.

BOOS Core and tomorrow

Today, we have told about BOOS Core for TMS320C64x Single Core Digital Signal Processors family of Texas Instruments Company. We have implemented this core like a product which helps anyone to see the developer's world of embedded software with new eyes. This world is the world of object-oriented intellection. We take steps every day for improving the core. We look for the ways to uncover new opportunities, to enhance a number of objects which describe hardware units. We strive to expand the BOOS Core application scope. Follow us, we are changing the usual.

Back to events list

Subscribe on Baigudin Software project events


* — Field must be filled