Iterative and incremental development/agile development model

eBinder can perform unit verification for each task by using partial loading and task generation functions. After unit verification of one task is complete, incorporate eBinder into the system to perform system verification. Repeat this cycle to proceed with development.

In addition to debugging by the task unit, eBinder also supports development using a process-based real-time operating system such as  eT-Kernel/Extended or eMCOS POSIX.

  Development using eT-Kernel Multi-Core Edition for multi-core processors is also supported.





Development procedures using the iterative and incremental development model



1. Module groups such as kernels, middleware, and verified user code that does not need to be debugged operate in a run-time environment. Programs that need debugging are developed in task/module units. 



2. Partially load the compiled object program into an operational run-time environment.



3. Dynamically generate the partially loaded object as a new task. 



4. Attach the dynamically generated task to the  Task Level Debugger and debug it.  



5. If bugs are discovered using the Task Level Debugger, then:   



6. Use an editor and other tools to fix the bugs.



7. Recompile the corrected code. 



8. Reload the object with corrected bugs into the operational run-time environment. 



9. Dynamically generate the reloaded object as a new task.



10. Attach the generated task to the Task Level debugger, and debug it.




11. Use the Task Level Debugger to verify the bug fixes..



12. Once debugging is complete, add the object to the system (static link).  



13. After the task unit verification is finished, use system analysis tools (EvenTrekPartScope, and Real-time Profiler ) and so on to verify the entire system. Repeat this cycle to proceed with system development.



13. Once task verification is finished, verify the whole system using the system analysis tools (EvenTrekPartScope, and Real-time Profiler).


Development using eT-Kernel/Extended


eBinder supports development using a process model real-time operating system with memory protection functions, such as eT-Kernel/Extended. Key points regarding the functions and features provided by eBinder for development using eT-Kernel/Extended are described below.



Program loading

eT-Kernel/Extended has a loader for dynamically loading programs in the operating system itself. This loader function can be used to load processes and system programs. Other kernel applications can be loaded with the partial loading functions provided by eBinder.



Debugging

With eBinder'sTask Level Debugger, not only can individual tasks in an eT-Kernel/Extended process be debugged at the task level, process level debugging can also be performed by stopping all tasks in the process. It is also possible to debug all programs handled by eT-Kernel/Extended, including system programs, shared libraries, DLLs and so on without worrying about information such as addresses where everything is stored.



System analysis

Even when using eT-Kernel/Extended, it is still possible to utilize EvenTrekPartScope,and  Real-Time ProfilerEvenTrek can be used to acquire trace information for a task group inside a process as well as trace information for a task inside a system program or other kernel application, in addition to other information. PartScope can be used to reference information such as processes and loaded modules, task information inside a process, and information for the different types of operating system resources used by a process.



Platform development support

eBinder's Platform Packaging Functions can be effectively utilized. In particular, this supports the distributed development of large-scale system development by large numbers of people that eT-Kernel/Extended excels at. Platform packages (PLP) can be easily created by using the platform creation template information included standard in eT-Kernel/Extended.

Back to top

Development using eT-Kernel Multi-Core Edition, eMCOS


eBinder also supports development using eT-Kernel Multi-Core Edition.just like eT-Kernel for single-core. As in the case of a single-core processor, in addition to the ability to develop using an iterative and incremental development model model in task units, it is also possible to debug tasks and processes in both SPM and TSM scheduling modes.



Task Level debugging

Synchronization between tasks and accurate exclusion are especially important in the case of a multi-core processor. It is possible to resolve design issues by using the Task Level Debugger. The Task Level Debugger can debug at the task level. It is possible to open a window for each task, to break individual tasks without stopping the entire system, or to step-execute a task to verify multiple tasks in parallel. With True SMP Mode (SMP architecture scheduling), debugging is possible without the need to be aware of the CPU core on which the target task is running. Since eBinder automatically tracks changes in the CPU core, it is possible to simply concentrate on debugging the task. In addition, under Single Processor Mode (AMP architecture scheduling), it is possible to debug using the exact same method as with previous single-core processors.





Analysis among programs on different CPU cores and the entire system

Check the behavior of programs running on different CPU cores graphically with the system analysis tool, EvenTrek. Interprogram collaboration or operation of the entire system is shown from an overhead view. The following image is an EvenTrek screen showing the analysis result of a program operating on a multi-core processor with four CPU cores.

It shows a program running on four CPU cores with tasks and objects color-coded depending on the cores.

The next image is a chart focusing on the behaviors of tasks and objects running on two particular CPU cores. EvenTrek can filter specified CPU cores for clarified display, and easily identify a behavior by narrowing down on an analysis target.

The following is a chart focusing on behaviors of tasks and objects running on one particular CPU core. Debug in this display mode when analyzing a program that runs in single-processor mode (SPM). This display can be used when migrating software originally designed for a single processor.

Back to top


Development Tools and Functions  
 Reusing Software Assets