-
13.03.2012
Mike Wall concentrates upon the aspect of optimizing and boosting performance of code during porting. Starting with an explanation of AMD64 architecture's advantages, the author discusses several methods of increasing code's performance including use of compiler switches, intrinsic functions, assembly and many more. In addition he also describes advantages of using CodeAnalyst tool when optimizing the code. In the article you will find some useful examples of code.
-
14.02.2012
In his post, Bruce Dawson explains what technique he and his Valve team use to find and fix 64 bits related pointer truncation bugs. A code sample is taken as an example.
-
27.01.2012
In this short post, the author tells us about his experience of using two static analysis tools each of which provides its own technique - Address Sanitizer (ASan) and Clang Static Analyzer.
-
11.01.2012
The article explains the differences between 32-bit and 64-bit systems from the viewpoint of the entire system structure consisting of three components or levels: CPU, operating system and applications. The basic principles of architectural arrangement are explained, and the common questions about 32-bit and 64-bit systems are addressed.
-
06.01.2012
The post focuses on the false idea that static analysis tools are testing tools or can be a good substitute for them. The author explains the difference between various kinds of testing and static analysis bringing out the point of the latter and its role in development. He agrees that static analyzers are necessary tools, but they are intended for detecting a "narrow band of code-related defects".
-
13.12.2011
This short post gives you some tips about how to choose a static analysis tool for your projects. Following these tips will help you to maximize your choice.
-
30.11.2011
The WOW layer present in the 64-bit Windows and the redirection mechanism it employs causes troubles for IT-security tests. The article explains the nature of these troubles and tells how to adapt existing analysis tools to handle this issue.
-
07.11.2011
The post refers us to an article by Coverity describing the benefits of static analysis and mentioning three analysis techniques it can provide: dataflow analysis, interprocedural analysis and false-path pruning. Each of this technique is illustrated by a code sample.
-
06.10.2011
The author uses a sample code to show how to set compiler and linker options to build a C++ application for 64-bit Windows. Each step is commented upon.
-
05.10.2011
Static analysis includes many techniques each of which helps developers to find various bugs and issues at different stages of the development process. In his article, Arthur Hicken describes these techniques (peer code review, pattern based analysis, flow analysis, metrics, compiler/build output) and the types of problems they are meant to solve.
-
11.09.2011
The article concerns the C++ code analyzer integrated into the Visual Studio 2012 development environment. The author speaks on the improvements introduced into the new version of the application and cites several code samples to show how it works and demonstrate various features of the analyzer. The text is complemented with screenshots explaining how to handle the analyzer.
-
06.09.2011
This post describes the stack frame layout of the x64 architecture focusing mainly on Linux and other operating systems that follow the official System V AMD64 ABI. The author gives diagrams and code samples to show the specifics of stack frame layout on the x64 platform.
-
01.09.2011
The article deals with the technology of static analysis. The main principle of static analysis tools' operation is explained and different techniques that comprise static analysis are described. Among them are bug pattern matching, data-flow analysis, abstract interpretation, model checking and program querying. The author also mentions tools specializing in each of these techniques. Information given in the article can help students in trying to make their own tools.
-
27.07.2011
Compliance with coding standards accepted in a company or a development team helps developers to avoid bugs and focus their attention on the general and more efficient review of the code. Unfortunately, the human factor often interferes with the necessity of following the rules, so there should be techniques of automated enforcement of coding standards. The article describes two widely-used static analysis tools that can be useful in solving this task - PC-Lint and RSM.
-
22.06.2011
This item includes an interview with Jill Britton who tells about the trends in the static analysis field, most common problems they meet when testing code, testing approaches applied in different areas and the exclusive method of code analysis created by the PRQA company.
-
04.06.2011
In his article, Magnus Unemyr discusses the problem of lack of up-to-date tools for embedded developers. According to him, while embedded software systems get more complex, tools intended to help developers in the development process still remain at the same level as 20 years ago, addressing common tasks (editing, compiling and debugging) without getting more flexible and powerful and capable of addressing a wider set of tasks. Among these are tasks of preliminary graphical modeling of the project's code to come, tracking changes in code and creation of version control systems, bug reports, automated unit-test development and many other things.
-
01.06.2011
The author of this article gives recommendations on how to improve quality of embedded software using static analysis. These recommendations include establishing software quality models and objectives, using language subsets complying with coding standards and proving absence of run-time errors.
-
20.05.2011
The article concerns the method of code review and explains the principles, types, steps and levels of this process as well as tools to be used for code review. The author also provides a list of examples demonstrating most common programming mistakes of different sorts.
-
07.05.2011
The post describes the FlexeLint tool which is, according to the author, one of the best and least expensive static analyzers for analyzing C and C++ code. The article contains numerous code samples illustrating errors the tool can detect and some of its specific features.
-
19.04.2011
The article presents a large research on the TDSS family of malware programs and consists of three parts each of which describes certain aspects of the TDSS rootkits and bootkits, including internals of the malware, mechanisms of rootkit distribution, specifics of bootkit installation on various systems (x86 and x64) and embedding into the bootsector. The processes of infecting the system are described in detail and illustrated by plenty of tables, schemes and figures.
-
04.04.2011
Microsoft has added the new Code Analysis feature in the Visual Studio 2010 development environment. This feature performs static analysis on code and will help developers to find various potential problems at different levels. This course is intended for developers to get acquainted with Code Analysis and learn the principles of handling this feature completing some exercises.
-
22.03.2011
The author tries to bust the myth about static analysis saying that it gives 100% code coverage and can find all vulnerabilities and defects. To explain why it is not so, he gives examples of what static analysis is unable to do or cannot do well. In general, these examples come to issues of testing an outside located code the analysis cannot access to.
-
27.02.2011
In his post, the author speaks on various static code analysis tools intended to perform code auditing as an alternative to formal methods. He gives tips on how to use these tools according to programmers' needs and circumstances.
-
31.01.2011
Static analysis tools being able to find security vulnerabilities in source code, many firms adopting the static analysis technology feel the urge to compare different static analyzers to each other to find the best solution. Gary McGraw explains why this task is not so easy at it may seem and why comparing any tools without bearing in mind crucial pitfalls resembles comparing fruit and aardvarks. The author also gives advice on what to choose as the best criteria for tool comparison.
-
14.01.2011
Guy Steele's presentation expresses his idea that it is not the programmer's job to think about parallelism; instead, a new approach is required to build programming languages that would provide ways to run tasks in parallel and support algorithms built on independence and build-and-conquer principles rather than on linear decomposition of problems.
-
06.01.2011
Walter Bright describes an interesting approach he took from the sphere of flight mechanical design and started applying to programming. What he does and suggests other programmers should do is to look for certain patterns of bugs occurring persistently and once some pattern is found, think how to change the programming process to avoid this pattern in future. Among possible ways, he offers changing coding standards, programming language, testing methodology and so on. The post is supplied with code samples containing various bugs, the author suggesting certain ways of solving for each of them.
-
04.12.2010
The article was created in an attempt to cover all information concerning Code Analysis integrated into Visual Studio. It is divided into three sections: "The need of Code Analysis", "Performing Code Analysis on your code" and "Making your own code Analyzable". The first section explains why developers need Code Analysis, while the second section contains code samples on the main patterns of bugs and errors the Analyzer can detect. The third section tells you how to write and edit your code so that the analyzer could check it fully and not fail to emit important warnings. The article includes numerous code samples to illustrate the main points.
-
17.06.2010
Since 32-bit applications are still popular and are actively used on 64-bit systems, it is good to know some typical issues of the Windows 32-bit on Windows 64-bit layer (WOW64). The paper concerns issues related to limitations of WOW64, mechanisms of registry redirection and registry reflection, file system redirection mechanism, references to files and variables, binding to 32-bit and 64-bit DLLs, application installation and startup and kernel-mode drivers. In the related sections, the author tells how to avoid these problems. The paper also demonstrates some techniques of handling 32-bit and 64-bit applications on WOW64. At the end you will find a brief list of best practices to stick to when working with 32-bit programs on WOW64.
-
24.04.2010
Sid Sidner, director of security engineering in the ACI Worldwide company, tells about static code analysis as the best way to ensure software quality and security. He explains the working principle of static analysis tools and gives a list of questions and recommendations for developers to choose the right static analysis tool to integrate into development processes. The author also shares his experience of working with some of static analysis tool vendors and explains by the example of his company by what considerations they were guided when choosing a tool.
-
28.01.2010
This paper discusses two technologies of thread programming in relation to multi-core technology – MPI and OpenMP. The author explains the differences between them, the underlying principle of each technology and compares performance results obtained in programs written with MPI and OpenMP. He also touches upon a hybrid approach to multi-core programming when both MPI and OpenMP are used. The paper is written very clearly and is supplied with illustrative schemes, screenshots and tables.
-
01.01.2010
In this article, the Coverity developers share their experience of developing and commercializing their own static analyzer as well as conclusions and lessons they draw from this experience. The authors formulate what they have called "laws of bug finding" and discuss various specifics of implementing a good static analysis tool.
-
21.12.2009
Processor and cache topology information is important to manage various processor practices such as task scheduling, performance optimization, licensing policy enforcement and so on. The paper discusses the principle of processor topology enumeration algorithm and specifics of its implementation in the Intel® 64 architecture processor. The author also touches upon cache topology enumeration. The paper has some illustrative schemes and an appendix for the examples.
-
11.11.2009
Irregular algorithms require using task pools but there is an issue of busy waiting that occurs at this point that wastes the computing resources and has no solution in OpenMP. Michael Suess and Claudia Leopold consider the task pool variants that can be implemented in OpenMP and compare their performance results. They also propose possible ways of enhancing the OpenMP specification to solve the problem of busy waiting.
-
08.10.2009
This large section on Microsoft Corporation site provides programmers with many papers and notes on various topics related to using 64-bit versions of Microsoft Windows, 64-bit programming, 64-bit platforms and other related subjects. You will find many useful tips and guidelines on how to work on a 64-bit system with a 64-bit version of Windows.
-
01.10.2009
The paper focuses on the issues of data alignment applying to IPF, x86 and x64 and covers all basic alignment faults. The author explains how data alignment is organized, how to avoid alignment issues and what to do when it is impossible. In the end of the article, he gives a brief list of tips on how to deal with alignment issues as a summary of the article's content. The text is accompanied with graphs and code samples.
-
30.09.2009
Written in a very clear and lively language, this paper touches upon the concepts of multithreaded programming and includes several sections describing various approaches and aspects related to this technology: multitasking, multithreaded programming basics, thread management, synchronization, strategies, as well as task parallelism, data parallelism, pipelining, tools and libraries for multithreading, graphical programming and debugging tools. In other words, the paper covers the most important points of multithreaded programming and will be helpful for any developer in mastering it.
-
18.09.2009
OpenMP is very convenient when working with multithreading but it has its own weak points. The authors of the article describe some of them sharing their experience of using OpenMP in a program performing a standard sorting algorithm. There are two problems they have encountered: recursion and busy waiting. To solve each of them, the authors suggest several solutions whose performance is analyzed and compared then. Some suggestions on improving OpenMP specification are also made.
-
15.09.2009
This Wiki-based resource is a database presenting a collection of various defects and errors in the sphere of high performance computing gathered by developers through practice. All the defects are arranged in several groups (for example, related to synchronization, memory management, etc). Programmers and developers are encouraged to provide feedback and enlarge the base with their knowledge about such defects.
-
05.09.2009
In the world of rapidly developing programming technologies it is important for all software developers to decide what standard and programming model to choose as universal to save time and money. The Open Group argues that LP64 programming model be the best solution for 64-bit programming. This conclusion is drawn from the results of analysis and comparison of ILP64 and LP64 models against several evaluation criteria, each being thoroughly commented and explained. Among these the authors list portability, interoperability with 32-bit environments, standards conformance, performance effects and transition costs.
-
03.09.2009
Wiki-resource devoted to static code analysis. It describes the essence of this technology and provides a lot of links to other materials on static analysis tools and related domains.
-
02.09.2009
This short post describes some C++ static analysis tools that can help developers to find some specific errors related to code duplication, cyclomatic complexity as well as general programming errors. The author also gives some tips on how to integrate static analysis tools into the development process and find newly introduced errors as soon as possible.
-
27.08.2009
This article will be interesting for every user involved in C++ programming while it describes the authors' effort to investigate the most popular C++ code analyzers on the basis of special rules and sample error patterns to be analyzed by the tools. The description of the testing base and the results are thoroughly commented and shown in various tables and code samples.
-
21.08.2009
This is one more article devoted to using static analysis to test medical devices' software. The authors explain how static analysis may be helpful in post-market testing and maintenance of medical devices and study the results of tests performed by the tool CodeSonar as an example.
-
06.08.2009
In his article written with much irony, Jack Ganssle touches upon the topic of inefficient tools provided by dishonest vendors. He explains the complicated situation in the field of software development and describes thinking and behavior stereotypes spread among developers, company bosses and vendors that lead to this vicious cycle when customers' needs are left unsatisfied despite a great many of ads and promises.
-
03.08.2009
A very large and solid article devoted to two topics: x64 architecture and Windows Vista. According to these topics the paper is divided into two main sections. The first section is devoted to x64 and explains the basic principles of the architecture's assembly, C/C++ programming for it, WOW64 operation, interprocess communication and many other aspects relating to this topic. The second section devoted to Windows Vista deals with operation principles of and improvements in this operating system, as well as various tools and security mechanisms, some issues relating to using Visual Studio environments etc. There is also one more section describing .NET Framework 3.0 technology and interfaces that supply it.Although this article is far from being exhaustive, it can serve a very cool source for those programmers who are mastering x64 architecture and Windows Vista. Its pluses are in its accessible and lively manner and a great number of code samples and illustrative screenshots.
-
26.07.2009
This paper is a presentation covering most aspects of porting 32-bit code to Windows running on AMD64 platform and includes several sections: AMD64 technology concerning some features of this architecture, 64-bit Windows for AMD64, porting issues, maximizing multiprocessor performance and recommendations on tools and additional resources. Each section includes schemes illustrating this or that feature and theses to be considered. The main plus of this paper is a concise character of description allowing coverage of many really important things.
-
26.07.2009
Creating irregular parallel algorithms with OpenMP is challenging yet possible task and this paper demonstrates this by an example of an algorithm implementing a breadth-first search. The major problem that occurs here is the problem of lacking of thread cancellation support. The authors describe the mechanism of thread cancellation and offer a way to work around the stated problem and propose some changes to the OpenMP specification as well.
-
12.07.2009
In this paper, the authors continue to investigate OpenMP drawbacks regarding C++ and offer nice solutions to improve it. This time it is the singleton pattern that serves as an example demonstrating OpenMP capabilities and weak points. The authors consider several methods of implementing a thread-safe singleton, analyze the problems encountered and offer possible workarounds and solutions. Performance tests are also provided for each method and then the best solution is given.
-
05.07.2009
The article "64-bit ODBC" provides detailed information on using 64-bit ODBC on 64-bit Linux, Unix and Windows platforms. Thanks to thorough introduction into the sphere of 64-bit and clear description of the basic principles of 64-bit technology and its advantages over 32-bit one, this paper can serve as a good manual for every user who wants to know how to manage 64-bit ODBC. The authors give detailed instructions on using various ODBC drivers on 64-bit Linux, Unix and Windows platforms illustrating them with good examples. Besides, the paper contains the FAQ section covering the most urgent issues and questions of using 64-bit ODBC.
-
04.07.2009
Those programmers who are planning to convert their projects created in Microsoft Visual Studio environments for 64-bit Microsoft Windows on AMD64 processors but face some problems now have a good opportunity to realize their plans: the article "Configuring Microsoft Visual Studio Projects to Support the AMD64 Architecture" provides the necessary information. It begins with an overview of tools for AMD64 by Microsoft and continues to give detailed instructions and tips on configuring such Microsoft Visual Studio environments as MVS 6, MVS .NET and MVS "Whidbey" to work with the AMD64 command-line tools. Besides, there is a separate section devoted to debugging AMD64 applications. The article contains a lot of illustrative screenshots.
-
23.06.2009
What parallel programming model will be 10 years from now? The author of article tries to find an answer and gives an overview of tendencies in the modern computer world quoting Microsoft chief researchers Burton Smith and Craig Mundie. Such topics are covered as development of parallel programming languages and improvement of processor chips.
-
17.06.2009
Although this paper is not of prescriptive character, it will be useful for many developers facing the task of porting 32-bit managed code to 64-bits. Beginning with a brief explanation of managed code's working principles in a 32-bit environment, the article describes issues of porting this code to a 64-bit environment from the viewpoint of several aspects: using platform invoke, COM interoperability, unsafe code, marshalling and serialization. When describing each aspect, some recommendations and code samples are given.
-
14.06.2009
The author of the article focuses on improving the process of C++ code development. He describes the main things to be considered while analyzing, debugging and enhancing the code. These include using static analysis tools, creating a suite of unit and regression tests and so on. The article is divided into four sections devoted to various techniques and contains code samples.
-
12.06.2009
The paper is divided into two parts: "Introduction to 64-bit programming" and "64-bit programming in practice". In the first part you will find description of the basic differences between 32-bit and 64-bit executables, Win32 and Win64 and x86 and x64 processors from the viewpoint of AMD64 and EM64T processors running on 64-bit Windows. The second part concerns various practical aspects of 64-bit programming and conversion of 32-bit code to 64-bit, such as change of data types, alignment requirements, using Windows structures in 64-bit programming, choice of register and so on, including optimization and refinement issues. This section provides crucial instructions and recommendations on accurate 64-bit programming. Pay attention that the task of 64-bit programming is viewed in this paper within the framework of using GoAsm, GoRC and GoLink, however, developers using other tools will find it interesting too.
-
08.06.2009
Written in a humorous manner, this blog-note is intended to cross the t's and dot the i's what memory management is concerned. To those programmers who have false ideas about this process and mix up notions "physical memory", RAM and "virtual memory" Eric Lippert explains the tricks of memory operation and actual causes of "out of memory" error.
-
23.05.2009
This article presents a study of how Linux kernel developers respond to bug reports generated by a static analyzer. The authors find out that most developers prefer to sort bug reports in several categories and show what factors affect decisions made about triaging certain types of errors or, on the contrary, what makes developers refrain from triaging and reviewing corresponding code fragments. The authors' conclusions are supported by plenty of graphs and tables.
-
21.05.2009
If you are creating 64-bit software for 64-bit AMD processors, you will find this article really valuable. Its general purpose is to discuss issues of using Microsoft Platform Software Development Kit - a toolkit intended for developing 64-bit applications for AMD64. There are three chapters: the first chapter touches upon technical preliminaries and background for using this toolkit; the second describes the procedures of building applications using Microsoft Visual Studio .NET on a Windows 32-bit development system; the third describes the use of the Platform SDK for building or porting applications using Microsoft Visual Studio 6. Each chapter provides a detailed algorithm of installing and configuring the necessary tools.
-
18.05.2009
This paper touches upon the task of portion an application to 64-bit Linux installed on HP Integrity servers. It includes many sections describing the basic issues the programmer might face during the port. For example, such issues are discussed as endianism, standard type definitions, pointer assignments, bit shifting and many others. The paper also includes a brief list of tools to aid the programmer in the process of porting (Intel C++ Compiler, GCC, GDB, DDD, Splint). The text is supplied with many tables and code samples for a better understanding.
-
05.05.2009
This FAQ serves as a brief introduction to OpenMP technology and its usage on HPCVL Sunfire SMP computers. It provides detailed answers to the ten most frequently asked questions about the technology covering its working and implementation principles, examples of usage, etc. The answers give some useful links and references for more details.
-
13.04.2009
A very brief note on porting 32-bit code to 64-bit that concerns some issues developers should pay attention to (use of data types different in 32-bit and 64-bit modes) and gives a couple of tips on using printf modifier.
-
12.04.2009
Migration of code to 64-bit platforms involves specific issues related to changes of sizes of base types and their interaction. Irving Rabin explains in his article what most basic and crucial problems might occur during porting and how to solve them using static analysis tools to make code architecture-independent. The author touches upon such problems as changes of sizes of pointers and long type, casting between pointers and integers, padding issues and some others. The article gives recommendations and rules on dealing with them and discusses static analysis based approaches which might be used for each case.
-
29.03.2009
In his article, Herb Sutter discusses the problem of concurrency becoming the next approaching revolution for software development, its causes, consequences and costs. A major part of the paper is devoted to analyzing the current state in the computer industry and explaining why sequential applications cannot benefit from the throughput gains any more and must yield to concurrent (mainly multithreaded) software; and how to deal with this problem as well. The paper is written in a lively and ironical manner but provides a truly serious and thorough review of the coming changes. Sure, it will be interesting and helpful for every developer.
-
29.03.2009
The author of this note provides a list of tools for C++ analysis where he describes various commercial and open-source tools. For each item there are a brief description and a link to the related site.
-
24.03.2009
In this paper, the authors give an overview of the most common mistakes made by novice programmers when using OpenMP. All the mistakes are arranged into two groups: correctness mistakes and performance mistakes. They are all explained and illustrated in detail and ways to avoid them are given. The authors also provide information on which compilers can and which cannot spot these mistakes.
-
16.03.2009
Using threads efficiently is a key to high performance and Herb Sutter dwells upon the problem of "up-leveling" this low-level tool of concurrency through isolation data and work of each thread. The paper discusses the techniques of improving the code with threads on the examples of three standard cases: GUI programs, sockets and pipelining. For each case there is a code sample and thorough explanation and guidelines on how to improve this code using special techniques.
-
12.03.2009
The paper is devoted to the type size_t and its appropriate use. Within the framework of the paper, the author touches upon the problem of portability and explains how to use size_t to improve portability, efficiency and readability of the code you want to port.
-
07.03.2009
Kerry D. Wong demonstrates differences in C++ code performance when performing the operation of matrix multiplication using OpenMP and the libraries uBLAS, cBLAS and MATLAB. He gives the code samples showing changes introduced in the code and comments them making conclusions about the performance change. At the end of the article, there is a table comparing the obtained results.
-
03.03.2009
This article considers issues of porting 32-bit source code to 64-bit environment within the framework of 64-bit Intel architecture. Andrew Binstock touches upon such urgent problems as changing sizes of the base types like pointers, integers and longs on various platforms, porting device drivers and binary portability. The text contains a lot of links to the useful resources devoted to the issues discussed.
-
26.02.2009
Long collaboration between Linux and Intel processors makes it possible to port Linux-applications to the 64-bit Intel Itanium processor nearly painlessly. The article focuses on each step of this process and gives a lot of guidelines concerning various aspects of the port: use of commands, data types, avoiding packing, padding and alignment issues etc. Each guideline is illustrated by code examples.
-
23.02.2009
Written in a somewhat ironical manner, the article explores the reasons for the lack of quality 64-bit software in the rapidly developing world of 64-bit processors. The author cites some famous software developers working in various companies and comes to the conclusion that the main reason for the problem stated is lack of motivation to completely move to 64-bits. The paper will be interesting for all programmers and users dealing with 64-bit computers.
-
19.02.2009
Nowadays, when system reliability depends upon software rather than hardware, it is very important to improve quality of embedded software. Static analysis is a perfect technique for this purpose. The article discusses the classification of static analysis tools and describes some of the most popular tools used for various purposes (general-purpose, Java-oriented and security control tools). Another section of the article is devoted to the issues of integrating static analysis into the software development process and explains each step of this procedure. The text contains illustrative schemes and code samples.
-
17.02.2009
The so called N-Queens problem is a good and interesting example to demonstrate using various new and already existing parallelizing techniques provided by Intel Parallel Composer. The paper consists of three sections. The first one introduces the problem and the algorithm of solving it. The second section offers a number of ways to parallelize this solution and tells about advantages and disadvantages of each method. The third section provides their comparison. The paper includes a lot of code samples and illustrative screenshots and will be interesting to everyone involved in parallel programming.
-
12.02.2009
In this note, the author explains how to set Visual C++ 2008 Express Edition to be able to compile applications for 64-bit Windows with its help. The note provides thorough instructions and tips on how to use the compiler's abilities to a full extent. As the author says, though the decision he offers can be rather dangerous, still it is worth applying.
-
30.01.2009
In his note, the author touches upon the problem of multithreaded applications designed for working on a single processor being subject to a misbehavior on multiple processors, and recommends two tools to manage parallel execution: Erlang and Intel's compiler suite.
-
23.01.2009
Absence of full support of CPUID instruction by Microsoft Visual Studio .NET 2005 on x64 platforms urged the author of the article to write three samples of code demonstrating a more efficient use of _CPUID and _RDTSC functions in 64-bit mode, supplying them with detailed comments.
-
21.01.2009
In this article, the author refers to the issue of the so called opportunistic thread scheduling and describes this technique's principle. He also touches upon QuickThread programming and explains how to employ opportunistic scheduling with the best result.
-
16.01.2009
In this whitepaper, the author discusses the use of OpenMP and in particular its library functions, environment variables and also gives some tips on increasing performance and debugging OpenMP applications. All these aspects are arranged in separate sections supplied with code samples or illustrative tables. There are also some notes about the Intel Thread Checker and the Thread Profiler tools which help work with OpenMP-applications. The paper would be interesting for every programmer dealing with OpenMP.
-
13.01.2009
This paper covers a wide range of aspects relating to 64-bit programming with Visual C++: it includes a table describing 64-bit compilers for the two x64-based and Itanium-based Windows platforms, overview of the features of Itanium processor, some Visual C++ 64-bit migration issues, tools for migration, changes in C++ libraries and many other things. Most sections contain links to useful resources. There is also a large FAQ section covering a lot of aspects on development on 64-bit Windows.
-
28.12.2008
The paper touches upon the issues related to OpenMP programs. By a code example, the author explains what problems the programmer may encounter and how to use Intel Threading Tools (Intel Thread Checker and Intel Thread Profiler) to simplify threading of a project. You will also find some tips on how to handle load imbalance and synchronization impact. The article contains thorough code samples and screenshots and will be interesting to every developer working with OpenMP technology and multithreaded applications.
-
21.12.2008
This paper with such a provocative title is discussing if there is sense in refusing OpenMP technology and if there is, how to 'kill' it by 2011. Written in a humorous way, the paper reveals the author's view upon the problem: OpenMP is still very popular and works quite well; so the only way to get rid of it is to let it vanish by itself when it stops meeting the growing complexity of computer technologies.
-
11.12.2008
In this paper, the author touches upon such a specific feature of Visual C++ as use of pseudo variables and format specifiers. Beginning with a brief description of differences between x86 and x64 processor architectures Kenny Kerr gives a list of most useful pseudo variables and describes their functions, in the same way he lists some format specifiers and their purposes. Besides, some examples are given of how you can use pseudo variables and format specifiers in visualizing calling conventions, error codes and debugging the security context.
-
03.11.2008
Since various code vulnerabilities make the code insecure, it should be thoroughly analyzed and made secure. The author discusses such common implementation-level vulnerabilities as race conditions, input validation, exceptions, SQL injection, buffer overflow; then he touches upon the question of code review technique, white box and black box analysis techniques and metrics analysis. At the end there are some links to a list of code analysis tools and related materials.
-
26.10.2008
This note describes the process of building a 64-bit executable using Visual Studio 6 step by step. All in all there are five stages and each is explained in detail. Besides the instructions themselves you will find some useful tips on debugging the ported project and as useful links to more information on the issues of porting to 64 bits.
-
24.08.2008
The article "32-bit pointers in a 64-bit world" touches upon the live issue of efficient use of 32-bit pointers in 64-bit environment with the purpose of performance gain. The author describes the operation principles of 'sptr' function serving for data alignment, and also peculiarities and limitations of its use. The article contains many clear and detailed examples of code to illustrate the mechanisms of encoding 64-bit pointers in 32-bits.
-
08.08.2008
In this interview, Adam Kolawa, CEO and co-founder of Parasoft, shares practical tips on how to use static code analysis with best efficiency. He tells in detail about the three main sorts of static analysis such as pattern-based static analysis, data flow static analysis and code metrics calculation, and also gives recommendations on how to use a static analyzer in a development process to obtain the desired effect and how the process of code analysis can be automated.
-
15.07.2008
A very useful document providing information on the major issues of creating drivers for 64-bit editions of Windows. It includes preliminary instructions on getting ready to development, technical data concerning data types and memory, tips and guidelines to coding and porting drivers. Many of these are supplied with clear code samples illustrating some of the issues described.
-
30.06.2008
The author of this brief post explains how concurrency helps unleash the power of multi-core systems and why OpenMP fits this task best. He lists the main benefits of threading and OpenMP advantages and also provides some background references on this technology.
-
11.06.2008
Parallel programming involves many difficulties and issues, especially concerning detecting specific bugs and bottlenecks in concurrent applications. The authors of this article tell you about the most frequent troubles such as race conditions, deadlocks and memory ordering issues, and then review some testing strategies and give recommendations on how to use them most effectively. They also advise some tools to aid you with concurrency testing (CHESS, The Intel Thread Checker, Chord, KISS, Zing) and give a list of characteristics to be considered in performance testing. In other words, the article includes all the necessary information on testing the concurrency bugs and improving performance of parallel applications.
-
20.05.2008
The paper is devoted to Parasoft Corporation's technology BugDetective for flow analysis that provides developers with many benefits such as the possibility of quick modification of code, flexible testing system, focusing on actual defects and errors, etc. The paper describes very thoroughly the working principle of BugDetective and how it can be used in combination with other testing techniques and includes many illustrative code samples and screenshots.
-
14.05.2008
Stack overflows might be very dangerous in high-integrity systems and are difficult to detect and debug, so it is very important to prevent them by analyzing the stack beforehand. This article explains how static stack analysis can help accomplish this task and what obstacles can threaten it and also gives some tips on how to use the compiler and special AdaCoreТs GNATstack tool for stack analysis.
-
29.04.2008
The paper concerns static analysis and the IBM static analysis tool IBM Rational Software Analyzer. It describes the static analysis technique in general and its benefits, discusses implementation of the IDM Rational Software Analyzer and provides the user with a thorough step-by-step instruction on how to specify the analysis rules for the tool, configure the analysis, run the analysis and view the results, export and report data and some other things. Every step is illustrated by screenshots.
-
11.04.2008
Computer game industry can benefit a lot from moving to 64-bit processors, and Microsoft Game Technology Group decided to provide game-developers with crucial information about porting 32-bit code to 64-bit platforms. The article covers basic issues relating to such aspects as pointer truncation, data types and binary files, older Win32 APIs and data alignment, assembly code and deprecated APIs and some more, and also gives some tips on how to avoid many problems relating to these aspects and increase performance of games.
-
21.03.2008
John E. West gives a brief overview of the teleconference devoted to the announcement made by Intel and Microsoft about creating two research-centers that would focus on the ways of improving the technology of parallel programming and the very way of how programmers "think" and employ parallel programming techniques. The author clarifies some points in this issue and cites some of the participants of the event. In particular, the main goal of the research-centers is to improve mainstream programming. The author also makes some conclusions about the good consequences of the step made by Intel and Microsoft.
-
03.11.2007
Although 64-bit processors can provide access to a 64-bit virtual memory address space, today's computers do not yet require this amount. Due to this reason and in order to simplify chip architecture, the AMD64 specification provides support for only 48 bits while Windows's addressing limit is just 44 bits. The author explains how using non-implemented bits in current processors as secondary data may cause unpredicted results and advises you to look ahead and make scalable applications.
-
20.09.2007
This brief note describes a common mistake of assuming that there is synchronization between the threads entering a worksharing construct when a FIRSTPRIVATE variable is used.
-
11.09.2007
In the era of multithreading programming coming closer and closer, it is important that developers be acquainted with technologies intended to simplify it. This paper is meant as a brief introduction into OpenMP technology but it is rather vast and includes several sections covering various important aspects. First of all, the paper explains OpenMP's pragma-based implementation and covers the following issues: the syntax, thread-safety, data sharing, execution synchronization and loop nesting. Each section contains a lot of illustrative code samples and descriptions of directives and clauses used for a particular purpose. Also, some tips on how to deal with the shortcomings are given. The paper will serve as a good source of basic information about OpenMP.
-
06.08.2007
In the article "What makes parallel programming hard", the author refers to the article by Anwar Ghuloum with the same title and adds some more points to the list of the factors that make parallel programming more difficult in comparison with sequential programming. Besides such factors as finding the parallelism, avoiding the bugs, tuning performance, future proofing and using modern programming methods, mentioned by Anwar Ghuloum, Michael Suess names added complexity, proneness of parallel programming to errors, little knowledge of innovative parallel programming systems and some more.
-
03.08.2007
What makes parallel programming hard? The author of the article with the same title answers this question proceeding from his programming experience and enumerates several factors in increasing order of difficulty. These are Finding the Parallelism, Avoiding the Bugs, Tuning Performance, Future Proofing and Using Modern Programming Methods. Resorting to logic explanations and lively examples the author gives a convincing proof of his viewpoint.
-
11.06.2007
Sometimes you might face a situation when you cannot port DLL to a 64-bit system together with the main module but still must have an access to it. This article explains how you can do it using a COM object and describes some things to be considered involved in this task, among them being some issues concerning alignment, data types, COM initialize function, security, performance, redirection process in WOW, kernel modules and setup procedure.
-
02.05.2007
The article is devoted to the problem of loop carried dependency when parallelizing or optimizing a for loop. The author describes various solutions to work it around and arising issues and demonstrates them by code samples.
-
17.04.2007
Written in a lively style, the article gives a review of 64-bit technology's advantages over the 32-bit one, and in particular touches upon 64-bit Windows operating systems. There are several sections in the article explaining the main features of 64-bit Windows systems and issues of using them, and also reviewing some 64-bit porting issues and porting guidelines. Despite being brief, the paper provides helpful information about dealing with 64-bit issues. It is also supplied with several interesting code samples.
-
19.03.2007
Despite its recent appearance AMD64 platform provides a great amount of various tools for Linux. The article "A Linux Toolbox for AMD64 Developers" briefly reviews a set of Linux compilers and debuggers for AMD64 platform by different companies and describes their specific features and abilities. The article is also supplied with screenshots of some of the tools.
-
11.01.2007
The purpose of this paper is to introduce the user into the basics of OpenMP. The author gives an overview of OpenMP pragmas, runtime routines and environment variables and illustrates using them by examples. She also gives some tips on what tools and methods to use to work around some errors and issues and increase code performance and safety.
-
01.11.2006
Integrating static analysis into software development provides the programmer with many advantages. The article reviews the most popular static analysis tools in several classifications including tools for Java analysis, security tools, etc. The authors also focus on various aspects of integrating static analysis such as creation of a coding standard, implementation of automated checking, the process of code review, results retention, managing new and existing code, and training engineers.
-
17.10.2006
With threading technology rapidly developing, it is necessary that C++ standard provide adequate support for it too. The paper describes a meeting of C++ specialists devoted to discussing the issues of creating threading standards for the next version of C++. Such issues were covered as memory model to choose, thread synchronization, thread launching and joining and exception handling. The article touches upon the most important reports and proposals by some of the meeting's members.
-
10.10.2006
Citing George Santayana's aphorism "Those who cannot repeat the past are condemned to repeat it", the author offers a detailed review of the history of computer industry development from the early solutions and technologies to the modern issues of 64-bit with the purpose to draw crucial lessons from the past to keep in mind. Written in lively and somewhat ironical manner, the paper provides though a serious and thorough analysis of the solutions, tendencies and mistakes of the past and pays attention to the development of 64-bit technology and problems relating to it.
-
06.10.2006
This blog-post concerns the technique of searching bugs in source-code lines of various projects with the help of the new tool Google Code Search. The author explains how one can easily use this tool to detect flaws in code by typing particular expressions and characters in the search line. There are some examples provided that illustrate this technique very clear.
-
20.09.2006
In his brief note, Michael Suess considers the ability of calling once-function in OpenMP which still lacks the mechanism of implementing this function. He gives some code samples explaining how to carry it out best of all.
-
14.09.2006
The article is aimed at the Linux developers who would like to develop 64-bit code for AMD64 processors. The author gives an overview of the basic Linux programming tools paying special attention to GNU open-source toolchain. You will find a list of some new command-line switches necessary for any 64-bit developer and other useful options. Besides, a toolset for manipulating binary files GCC Binutils is also described. In conclusion the author lists some other worthy tools for Linux.
-
11.09.2006
The paper presented in two parts introduces the readers into the basics of OpenMP technology and describes its various #pragma directives and principles of working with variables, threads and parallel sections. The author gives a good deal of code examples and thorough explanations and tips on how to deal with the issues presented in them. The paper will be surely helpful for all developers making the first steps in OpenMP.
-
21.08.2006
This article compares scoped locking and critical directive in OpenMP that both serve for handling mutual exclusions. The comparison is carried out by several points that are illustrated by code samples. After that the conclusion is made what technique is better.
-
12.08.2006
If you doubt that OpenMP is the best system to use when dealing with parallel programming in C/C++ and Fortran, read this article by Michael Suess where he explains the three reasons for choosing this technology: high level of abstraction, performance, maturity. Written in a natural manner, the article may serve a good brief overview of the main OpenMP's advantages.
-
01.08.2006
This wiki-resource is devoted to static code analysis tools for the most popular programming languages. There you will find a large list of various tools, both open-source and commercial, with brief descriptions and useful links for more information.
-
30.06.2006
As John Paul Mueller writes, "for many developers, the task of moving an application from 32-bits to 64-bits isn't scary; the problem is one of not knowing where to begin". In this paper the author offers 24 tips to consider before taking the move. They cover various aspects of porting applications from tips on using data structures and data types to those on providing 64-bit friendly installation packaging. Despite the brief character of these guidelines you will find all necessary information.
-
28.06.2006
A very interesting article devoted to the experiment Microsoft undertook by replacing its 32-bit Web servers with 64-bit AMD Opteron processor and Windows Server 2003 x64 Edition. Besides clear and lively language, a large plus of this paper is detailed analysis of the reasons of this step with reference to the whitepaper published by Microsoft and thorough investigation into its amazing results.
-
28.06.2006
Visual Studio 2005 environment provides developers with a good possibility to easily create 64-bit versions of applications. This article explains how to use this possibility to get the best result. The author gives basic guidelines on how to set the .NET framework, where to get its 64-bit version and 64-bit tools, and also considers some special problems for 64-bit .NET applications such as using PInvoke calls, COM components and Crystal reports.
-
27.06.2006
In this article Anderson Bailey explains how 64-bit mode enables acceleration of arithmetic and consequently performance of math-intensive applications. He briefly describes the principles and purposes of the three types of arithmetic provided by 32-bit mode (GPRs, x87 registers and SIMD registers) and analyzes the mechanisms of improving their performance in 64-bit mode provided by AMD64 architecture. The author also makes some conclusions about the spheres of software development that will especially benefit from this improvement.
-
12.05.2006
Linux-application developers facing the task of porting their programs will find much useful information in this article. Beginning with a brief discussion of 32-bit architecture's constraints and main advantages of 64-bit one, the author moves on to touch upon peculiarities of 64-bit Linux architecture and then gives many valuable tips to deal with various common issues of porting from 32-bit to 64-bit systems concerning declarations, expressions, assignments, numeric constants and many other aspects. Every point is illustrated by a code example.
-
11.05.2006
As seen from the title, this paper is intended for developers creating applications, compiler tool chains and virtual machines on AthlonT 64 and OpteronT ccNUMA multiprocessor systems using Microsoft Windows operating system. In the introduction the author touches upon the advantages of ccNUMA architecture over traditional symmetric multiprocessing systems. Further he describes the experimental environment where performance study was carried out and also gives instructions on how to read and interpret graphs. The next section contains a detailed analysis of the results received with the help of the synthetic test undertaken and recommendations for performance improvement concerning thread scheduling, data location and cache line sharing. Besides, some "myths" relating to memory access hops are debunked. A great advantage of this paper is its thorough investigation of performance issues and clear explanation of the results. Many recommendations are supplied with graphs as well.
-
11.05.2006
Matt Pietrek shares his experience of working with Win64 and x64 architecture and provides developers with useful information about 64-bit programming. The article is divided into three main sections. In the first one the author considers details of x64-based Windows implementation, including such issues as memory limits, address space, exception handling and so on. The second part concerns a set of instructions of the x64 architecture itself. The third section is devoted to developing for x64 with Visual C++ environment and includes instructions on how to set the environment, how to deal with some issues of making code Win64-compliant and how to debug the application. The article contains many code samples and illustrative tables and screenshots. Lively language is another plus of the paper.
-
11.04.2006
The paper deals with issues a developer may encounter when porting a 32-bit application to the x64 processor, and includes several sections devoted to explaining reasons for porting, giving some facts to consider before porting, and describing the steps of porting an application to a 64-bit platform. The paper covers only the most common points and rather briefly but it can serve a good introduction to porting 32-bit C++ applications to the x64 platform for those who has just faced this problem.
-
31.03.2006
In his article, Allan McNaughton touches upon issues of interoperability between 32- and 64-bit processes in mixed-mode applications that serve as one of the way to bridge the gap between 32-bits and 64-bits. The author pays special attention to WOW64 and describes its working principle and gives a typical example of interoperability problem caused by mixed use of 64-bit pointers and shared memory.
-
24.03.2006
Would you like to see a one-stop shop providing everything you need for 64-bit development? There is such a place - AMD Developer Central. With the help of Allan McNaughton you'll learn about the advantages of this source and a great variety of services and tools provided by it. For example, very good news for many developers is that such popular tools as AMD CodeAnalyst, AMD Core Math Library and AMD SimNow used for increasing performance, writing low-level code and other purposes are now free to obtain. And there are many other spheres you can benefit in from AMD Developer Central.
-
23.03.2006
In his brief blog-note the author dwells upon an idea to report various issues of 64-bit programming for a wide public. As we can see, this idea resulted in a kind of weekly e-magazine "64-bit Insider" providing interesting information on everything connected with 64-bit programming. The main plus of these publications is their easy-to-digest language so that even developers new to program migration and 64-bit software development could benefit from these materials.
-
01.03.2006
Nick Wienholt offers his help to you in mastering the C/C++ Code Analyzer that ships with Visual Studio Team System (VSTS). The article explains why static analysis is essential for C/C++ applications and how to launch and use this function in VSTS.
-
01.02.2006
In this article, the authors share their experience of porting an application with support of 11 operation systems to a 64-bit environment. Proceeding from this experience they single out the two major cross-platform migration issues: integer-long-pointer mismatches and implicit function declarations. They also touch upon some more hidden issues and in the end of the article, give valuable tips on coding and a list of useful 64-bit tools and techniques. The article will be interesting for all programmers and especially for those who face the task of porting cross-platform applications with large code to 64-bit systems.
-
13.12.2005
The article touches upon the topic of OpenMP support in Sun Studio software. The first section describes the working principle of OpenMP technology, its execution model and directives. The second section explains how OpenMP support is implemented in Sun Studio compiler and some most important tools. The article also discusses the issues of OpenMP applications performance. The text is supplied with illustrating graphs and schemes.
-
10.12.2005
In this weblog-post, the author touches upon the topic of OpenMP technology from the viewpoint of Chip Multi-Threading technology (CMT) that is to be become rather popular in the nearest future. The post gives an overview of OpenMP, enumerates its main advantages over other parallelization techniques and gives some tips on learning and using it.
-
11.10.2005
OpenMP technology helps developers create multithreaded applications more quickly and with less effort. The authors of this article are going to tell about the main features of this technology acquainting the user with the OpenMP constructs (in particular, synchronization pragmas and execution environment routines) and referring to some issues related to shared and private data, scheduling algorithms and non-loop parallelism. The article is supplied with many code samples and instructions on using particular constructs.
-
01.10.2005
Memory errors may cause a lot of problems when porting to 64-bit platforms. Rich Newman is going to share some guidelines on how to fix memory errors before porting an application. He touches upon the nature of troubles occurring when moving to 64-bits and explains step by step how to find and fix errors with the help of the so called mutation testing. You will also find some tips on how to detect problems of the 64-bit processor itself.
-
07.03.2005
In a brief but informative article Conrad Carter focuses on efficient use of switches in C/C++ compilers for providing high performance and good portability of 64-bit code. In particular, he considers Visual C++ 2005 and gcc 3.3.3. For each compiler a set of the most useful switches is given as well as thorough instructions on their use. In conclusion the author touches briefly upon AMD Core Math Library.
-
28.02.2005
As the authors put it, "the world of parallel programming today is diverse and complex", so they decided to make an overview of the current state of this sphere. For that purpose they proposed three subprojects that consist in surveying programmers and scientists concerning various aspects of parallel programming, comparing parallel programming systems with a standard set of tests and working out a wiki resource that would serve the best source of information on all the questions that may arise about the technology.
-
31.01.2005
One more brief blog-note by Raymond Chen where he explains the reasons why Win64 team chose LLP64 data model, showing by an example the rationality of their choice.
-
11.01.2005
As it is known, the main cause of problems when converting 32-bit applications to 64-bit ones is change of sizes of long and pointer types. Proceeding from that the authors of the article offer a set of some very useful rules of using types following which will help you avoid these problems. They cover various methods of improving your code and are illustrated by detailed examples.
-
19.10.2004
Porting applications to the 64-bit mode of the PowerPC 970FX processor is a specific task and Matt Tyrlik is going to encourage developers and help them eliminate main issues relating to porting existing 32-bit code to the new computing model. The article consists of three parts. The first one describes main issues you may encounter when porting C language software to the 64-bit computation mode of the PowerPC 970FX. This section covers data type changes, pointer arithmetic, function pointers and compiler options. The second part discusses issues of porting 32-bit assembly language software to the 64-bit computation mode and deals with TOC programming, assembly language data objects and function calls etc. The third part covers changes needed for supervisor-level software. The text is supplied with many code samples.
-
21.07.2004
Porting of multimedia codecs to 64-bit environment involves some challenges but done skillfully it provides a great increase of performance. The article focuses on the porting issues and ways to solve them. It consists of two main sections - "Porting Challenges" and "Optimization Techniques". In the first one, the author describes obstacles a developer can face before the porting process and gives some tips to avoid them: these tips include using SSE/SSE2 Instructions instead of MMX and 3DNow! ones, using intrinsics instead of inline assembly and using portable scalable data types. The second section dwells upon several techniques of optimizing the process of porting. They include extended 64-bit general purpose registers, loop unrolling, using aligned memory accesses and some more. Each technique is thoroughly described in illustrated by schemes and example of various codecs' codes. Besides, there is a brief note on porting and performance evaluation tools for codecs with an emphasis on CodeAnalyst.
-
20.01.2004
This article considers floating-point arithmetic for numerical computing on the example of summing square-roots on different architectures. The results of computation are thoroughly compared and described in several tables. The issues of the precision level and what to consider a "correct" result are also examined. The article will be interesting for everyone involved in floating-point computation.
-
14.01.2004
In this brief blog-note, Raymond Chen touches upon the AMD64 architecture and gives some tips on working with its registers supplying them with code samples.
-
11.11.2001
Proceeding from his own experience of modifying Nile application for the 64-bit Microsoft .NET Advanced Server, the author discusses the issue of porting applications to 64-bit systems. He gives some recommendations on how to prepare source code ready for the smooth port and describes the issues related to differences in data types and memory alignment. At the end of the paper, there are some good habits of working with 64-bits to keep in mind.
-
04.12.1997
Beginning with a brief history of UNIX system and computer industry's development, Andrew Josey describes the 64-bit data models (LP64, ILP64, LLP64), the principles of their implementation, their peculiarities and porting issues conditioned by differences between 32-bit and 64-bit data models. He goes on to speak about UNIX specifications' data size neutrality and some more issues of porting code to a platform with LP64 data model relating to declarations, assignment and function parameters, external interface, use of constants, pointers and so on. The author also gives some useful instructions to avoid these problems.