Forem: Satoshi Konno

Rust Implementation Guide - from efficient learning to implementation

Satoshi Konno — Sun, 19 Jan 2025 08:53:26 +0000

In the last issue [30], I implemented the same application in Go, Rust, and C (+ Python) and evaluated the implementation efficiency and speed with each language. In this article, we will summarize our views on how to learn and implement Rust efficiently based on our experience.

How to learn Rust

Rust is considered a language that requires a learning period before productivity is realized [5]. With statistics showing that more than 50% of people leave during the initial learning phase and many of them fail within a month [6], effective initial learning is especially important.

STEP1: Overcoming the Learning Readiness Phase

There are many esoteric interpretations of the Rust compiler (without explicit solutions) [11], but first learn the basics of the Rust compiler until you understand and can interact with its error content.

While Rust is rife with books and materials for beginners [5], there is a dearth of materials aimed at practical intermediate and above [5] has not improved much. In conclusion, instead of struggling with compilers in the dark, the shortcut to Rust mastery is to first improve basic skills with good learning materials, which are the primary resources shown below [7][8].

There are also scattered opinions that C/C++ is easy for skilled users to learn [7][9][10], so in terms of deepening the usefulness of Rust, it is also important to deepen the C/C ++ language may also be a shortcut to learning Rust.

STEP2: Practical project challenges

If your goal is to "learn Rust," you will have achieved your objective at this stage. However, the difficulty of Rust lies in the difficulty of practice, after overcoming the preparatory phase of the learning curve [5][11][12][15]. In conclusion, it seems to be efficient for Rust learning to start some kind of practical project [13][14].

If it does not follow the semantics of Rust, design patterns (experience) in other programming languages cannot be brought in directly [16], and trial and error is required. In terms of comparison with existing languages, the following tutorials may be helpful.

[15] Learning Rust With Entirely Too Many Linked Lists

As mentioned above, the situation [5], where there is a dearth of material aimed at the practical intermediate level and above, has not improved very much. As an actual example, you can read the divergence between the following materials recommended for beginners to step up and the practical subject matter [15] shown in the above tutorial.

In other words, because there is not as much "Effective" intermediate and above information as in other languages, you need to struggle with the Rust compiler and establish (pioneer) the following design patterns (experiences) [16] must be established (pioneered) by yourself while struggling with the Rust compiler.

Many books and materials that are considered intermediate level are simplified by limiting the field of application, both in a good and bad way. In conclusion, there are few things better than official materials, and a practical shortcut may be to deepen understanding by trial and error while going back to official materials in practice.

Books that are field-specific in title are an effective way to gain implementation knowledge of Rust in a specific area, serving as a Rosetta Stone of sorts. However, it should be understood only as one implementation example, and whether it is the best way or not may be reconsidered through practice.

Rust at Work

The most recent Rust community survey included a "Rust at Work" item [21][13], which emphasizes the adoption of Rut as a professional language. The most recent, 2021 survey results [13] show that while the rate of use at work has increased significantly from 42% to 59% in the previous year, industry adoption The lack of adoption in the industry was cited as the biggest concern (38%) for Rust's future.

Basically, a programming language is a means to an end and should be selected based on the circumstances of the target project and team. Based on this assumption, here is a list of items to consider when adopting Rust.

Consideration of project characteristics

First, it is important to determine whether the project to which Rust is applied is compatible with Rust semantics, in the sense of avoiding implementation complexity and performance degradation in Rust. Simply put, a project that is not stateless and involves parallel processing with data sharing in the Rust processing unit cannot be handled solely with Rust's move (Move) semantics, and ownership and lifetime management will become more complex.

For example, stateless web applications and[31], which can be handled naturally with Rust's move (Move) semantics and SEDA[32], which are concurrency models that do not require data sharing, the semantics of Rust adoption is unlikely to be a problem.

Also, if we ignore the compatibility and complexity of the implementation, the adoption track record of Rust in the same field as the project, and for what applications and at what scale it has been implemented, will be a good guide for making an adoption decision [14].

Secure core members

What is clear is that if you are at a stage where you do not have personnel proficient in Rust, and you cannot determine the compatibility of Rust with the characteristics of your project, you should avoid hiring Rust. Simply put, you should avoid hiring Rust out of curiosity.

It is essential to have a core team that is proficient in Rust. Conversely, if the core team has established design patterns for Rust implementation, it will be easier to add more people to the project, even if they are new to Rust.

Basically, if core members have established a template or methodology for implementing Rust in a project, new members can follow that style and extend the project structure even if they are not necessarily proficient in Rust.

Scope of Standard Library Offerings

Rust is a language that has strengths in system programming and situations where high performance is required, but the coverage and functionality of the standard library is on the poor side, similar to the C language. The standard library provided lacks functionality and speed [30]. memo/rust-eval-loc-perf/)[30][31], and other maturity challenges In some cases, the

Realistically, considering the scope of standard library offerings and the economics of the project, we will have to take the approach of developing a combination of third-party crates. In particular, for complex data structures and highly parallel processing functions, we are forced to rely heavily on third-party crates.

However, depending on the quality and maintenance status of the crate, the project may be more at risk, and this should be taken into consideration. Also, as with Perl's CPAN, crates are registered on a first-come, first-served basis, so even if a crate is published under a major name, there may be alternative crates of higher quality and more actively developed, so thorough investigation is essential before adoption.

Inheritance of past assets

Realistically, many will want to leverage existing development assets rather than implement exclusively in Rust, and Rust continues to see a high demand for interoperability with C/C++ language assets as an important issue [5][24][25][26][27][28][29].

Compared to C++, Objective-C, and Go, where interoperability with C is guaranteed at the language level and can be used simply by including header files, Rust's interoperability is one major barrier. Rust provides a FFI (Foreign Function Interface) to interface with other languages, but interoperation with C requires a separate FFI definition that shows the correspondence with Rust types. rust-bindgen[27], but there are also FFI generators such as [28][29] will be an important factor in the decision to adopt Rust.

Conclusion

While Rust is highly secure and performs well, learning Rust involves steep hurdles and struggles with the compiler, so effective learning methods and preparation are necessary. In the initial stages, it is important to cultivate a basic ability to understand and respond to compiler error messages, and to ensure that you learn Rust-specific concepts by using good official materials and books for beginning students.

When considering the adoption of Rust for a project, it is particularly important to confirm the project characteristics and the Rust proficiency of the team, and to establish appropriate design patterns and support systems.

We hope that by utilizing the learning materials and reference materials introduced in this article, you will be able to maximize the potential of Rust by establishing basic skills and then putting them into practice.

Rust vs Go vs C: Database and IoT Application Performance Benchmarks

Satoshi Konno — Sun, 19 Jan 2025 08:46:03 +0000

Rust is a language designed to be both secure and fast [1], and in recent years, it has been expected to make further strides as a professional language employed in business [3] [8]. However, the results of the 2021 survey [3] also show that while the rate of use at work has increased significantly from 42% to 59%, the lack of actual adoption in the industry was cited as the biggest concern (38%) about Rust's future.

In this article, to determine the practicality of Rust, we sought to compare and evaluate its implementation against application implementations with the same specifications in other programming languages, such as C and Go. We prepared two targeted evaluation applications, Database (Redis) and IoT (ECHONET Lite), to assess the efficiency and performance of practical Rust implementation.

In summary, Go is considered the best successor to C from a Better C perspective, followed by Objective-C, Rust, and C++. Rust offers safety and speed but has limitations in productivity, interoperability, and programming flexibility. Despite these challenges, Go stands out for its implementation efficiency and stable performance, making it a safe choice for general-purpose applications.

Evaluation 1 - Database Application (Redis)

This evaluation will compare C, Rust, and Go implementations of the Redis [19] specification in the database area as the same application. The official Redis implementation [19] is in C, while the Rust and Go implementations are unofficial subset implementations. The following is a list of databases using Redis used in this evaluation.

The Rust implementation is mini-redis [21], which was released as a learning tool for the Tokio [20] library, and the Go implementation is a sample implementation (go-redis-server) of my Redis-compatible database implementation go-redis [23].

Compared to the official Redis implementation [19], mini-redis [21] and go-redis [23] are subset implementations, and therefore cannot be evaluated for implementation efficiency using LOC (Lines of Code), only for performance.

Evaluation Benchmarks

The benchmark programs evaluated were performed with redis-benchmark, the official benchmark tool for Redis. The benchmarks are not a full set but are limited to SET/GET commands and are run every 10,000 iterations with the standard 50 threads.

The reason for being limited to only basic SET/GET commands is that mini-redis [21] is only a minimal command implementation, such as SET/GET commands, and we followed the benchmark parameters [22] in mini-redis [21]. Note that mini-redis [21] is the latest version at the time of evaluation and the environment is "Mac mini (2018) + macOS 12.6".

Performance Evaluation - C > Go > Rust

The results of the SET/GET command execution by "redis-benchmark" are shown below. The 99th percentile (p99(ratio)) value, which is used as an indicator for database operation, is shown at the right end of the table along with the performance ratio based on the C language.

In the evaluation benchmarks, the official implementations of redis-server in C [19], go-redis in Go [23], and mini-redis in Rust [21] were faster, in that order. A graph of the above table is shown below.

The C redis-server [19] was optimized and was about 3 times faster than the sample implementations in Go and Rust. Both Go's go-redis [23] and Rust's mini-redis [21] were implemented as samples, and both have room for improvement. Taking this into consideration, a brief review of the evaluation results for each programming language is presented below.

Rust

Compared to the official C redis-server [19], SET: 28% and GET: 41% slower, and compared to the Go implementation go-redis [23], SET: 78% (=2.879/3.663) and GET: 88% (=2.167/2.455) slower.

Since the Tokio [20] library has been released for training purposes, it is assumed that full-scale optimization has not yet been performed. However, to some extent, optimization seems to have been performed by comparing performance with the official implementation of Redis [19] [22].

It is positioned for learning the Tokio [20] library, and the implementation basically uses the Tokio [20] library, with the network part built based on the Tokio [20] TCP server (tokio::net::TcpListener). However, the key-value data management part of the database is implemented with the HashMap of the standard (std) library and Mutex of the standard (std) library for exclusive control, as in the implementation of Evaluation 2. Performance issues may be based on performance issues of the standard (std) library [18], such as HashMap [17], as in Evaluation 2.

Go

Compared to the official C redis-server [19], SET: 35% and GET: 46% faster, while compared to Rust's mini-redis [21], SET: 127% (=3.663/2.879) and GET: 113% (=2.455/2.167) faster.

Go-redis [23] is a framework for implementing Redis-compatible databases, and like mini-redis [21], the target of this evaluation is a sample implementation, so the implementation is simple. The speed difference from the official implementation was unexpected due to the assumption that there was little room for optimization.

Go-redis [23] and the sample implementation "go-redis-server" are implemented only with the standard library, and the key-value data management part of the database is implemented with sync.Map. It will be necessary to refer to the official implementation for performance differences with the official implementation, in parallel with identifying bottlenecks in the profiling.

Evaluation 2 - IoT Applications (ECHONET Lite)

This evaluation targets client-server function implementations of ECHONET Lite [9], a communication protocol in the IoT field. This implementation is an evaluation of an application for which the target requirement specifications (= ECHONET Lite [9] specifications) are the same, and the design and implementers are the same.

Evaluation Frameworks

The Rust implementation [12] of ECHONET Lite [9] implemented in C [11], Go [13], and Python [14] are compared. The basic ECHONET Lite [9] functions are implemented using the same design as far as possible, but there are some differences in function implementation between the languages. An overview of the differences in implemented functions is shown in the figure below.

The ECHONET Lite [9] framework implementation subject to this evaluation was implemented in C, Go, Python, and Rust, in that order, and basically follows the same design.

As explained in the ECHONET Lite [9] Specification, the basic Device function, the Controller function for operating devices, and the Database function for standard devices [10] defined in ECHONET Lite are implemented in all programming languages.

However, for the transport layer of the ECHONET Lite [9] specification, only the mandatory UDP communication function is implemented in all programming languages, while the optional TCP communicator is implemented only in C [11] and Go [13], with implementation in Rust [12] and Python [14] omitted.

Implementation Efficiency (≠ Effort) Evaluation - Python > Rust ≈ Go > C

The efficiency of implementation in Rust was evaluated in terms of lines of code (LOC), which was calculated using Tokei [16] and excludes comments and blank lines. The results of LOC calculation are shown in the figure below.

For Auto, only the source code, which is the automatically generated code defining the ECHONET Lite standard devices [10] and excluding the C language header file, was subject to evaluation. The graphs in the above table are shown below.

Taking into account the range of implemented functionality, the LOC evaluation results in the following order: Python > Rust ≈ Go > C, with the least implemented code. Below is a brief review of each programming language.

Rust

The LOC results show that (although there is no implementation of TCP functionality), the implementation rating is equivalent to Go, with a LOC efficiency of 53% of that of C. This implementation with Rust was implemented using only standard (std) libraries such as Mutex, with the exception of the UDPSocket issue described below.

Rust is a language that generally requires a learning period before it feels productive [5]. Therefore, in Rust, it is not simply ‘less LOC = more implementation effort’: even code with a low LOC often takes a long time to implement because the developer struggles with the Rust compiler. Also, the extremely high LOC of auto-generated code is due to the specification of a standard maximum line width (max_width=100) in Rust's formatter (rustfmt), which is excluded from the evaluation.

There are also restrictions due to Rust-specific move semantics and lifetime, which can make it impossible to bring in designs from other languages, which can lead to high design costs. In the current implementation, some design changes were made due to the limitations of introducing the Observer pattern for trait objects and the locking interval synchronised with the Mutex lifetime.

C

The implementation in C resulted in the largest LOC. The reason for this is that this implementation does not use external libraries and includes self contained libraries (e.g. strings, list structures, object-oriented structures, etc.) which are not needed in other languages, and wrapper classes (e.g. Mutex, Thread, etc.) for portability. The home-grown libraries are shared with other C projects and are not as heavily implemented in this application as the LOC figures.

Go

The LOC results show that the implementation efficiency is comparable to Rust, with an implementation rating of 63% of the source code compared to C. In Rust, there were issues with some of the standard libraries, but in the Go language, the implementation was carried out using only the standard libraries.

Basically, the C design is implemented in the Go language as it is in C. Unlike the implementation in Rust, the design in C can be diverted and implemented, and there is flexibility. In addition, the standard library is more extensive than that of the C language, which can be evaluated as being directly related to ‘less LOC = less implementation time’.

Python

The implementation in Python has the lowest LOC result in this implementation evaluation, because Python does not require parentheses ({}) in code block expressions, so a comparison with other languages that require parentheses (C, Rust, Go) requires a subtraction. Also, in comparison to Rust, the fact that implementations can be inherited contributes to the reduction of LOC.

Python also has the flexibility to straightforwardly transfer designs from C and Go. Apart from the execution speed issues described below, it may be the best prototyping language

Performance Evaluation - Go > C > Rust > Python

The execution performance of Rust was evaluated for the same level of functionality of ECHONET Lite [9], the target of the evaluation, with the same basic design implementation. The benchmark program evaluated was a node in which the controller and objects of ECHONET Lite [9] were implemented.

Evaluation Benchmarks

In the benchmark program evaluated, the ECHONET Lite [9] controller is a UDP client, and the object is a UDP server. The main loop, which is the basic sequence of the benchmark, consists of 12 UDP requests (Requests) from the controller and 12 UDP responses (Responses) from the object per execution.

To explain this in accordance with the ECHONET Lite [9] Specification, the ECHONET Lite controller itself is discovered by a UDP multicast request (ESV: 0x62) and the implementation-required properties of the node profile object (0x0EF001) contained in the discovered controller node (0x0EF001) are set to the following values (12). The benchmark is 10,000 iterations of the request (ESV:0x62) response (ESV:0x72) operation with the UDP protocol for the values of [10] (12 values). For the evaluation of implemented code, no optimization options were used in each environment. The environment is "Mac mini (2018) + macOS 12.6" and the details of the evaluation scripts are available here [15].

Performance evaluation results

The performance evaluation was measured by using the time command to measure the execution time of 10,000 iterations of the basic sequence shown in the evaluation benchmarks. The evaluation results are shown below, along with an overview of the compilation conditions and implementation techniques for each programming language.

In the evaluation benchmarks, Go was the fastest implementation, followed by C, Rust, and Python. Since UDP communication is asynchronous, data transmission and reception from a request (Request) to a response (Response) are implemented using the condition and channel mechanisms of each programming language. A graph of the above table is shown below.

Python was excluded from the scalability analysis due to its extremely slow execution speed. In order to compare performance with C language, the performance ratio of each programming language relative to C language is shown in the figure below, along with a brief evaluation of the performance results for each programming language.

Rust

The Rust implementation performed worse than the Go and C implementations, being only 33% as fast as C and about 20% (=33/160) as fast as Go. While the system (sys) time is comparable to Go and faster than C, the user (user) time is larger than in C and Go.

The cause needs to be investigated, but according to "The Rust Performance Book" [17] and "The Rust Language FAQ" [18], there are some standard (std) libraries, such as HashMap, that may be slow under certain circumstances.

In addition, the standard (std) library Mutex, which is used extensively in this implementation, is difficult to handle because its valid interval is the same as that of the target object, and there are parts where copy semantics are unavoidably used to avoid this. Other language implementations are zero-copy (Zero Copy), so programmatically there is room for improvement (although significant design changes are required).

In addition, the standard (std) library UDPSocket cannot support socket creation by the same port number, so a non-standard crate must be used in conjunction with the implementation of IoT-related protocols such as ECHONET Lite [9] and mDNS, which are the target of this implementation. In addition, although IPv6 functionality has been implemented, it cannot be enabled at this time due to an error.

C

Basically, the user (user) time is the fastest, but the system (sys) time is 2.5 times slower than Go and Rust. We had no concerns about the performance of the C language until this evaluation, but there may be issues with the use of standard libraries such as pthreads.

Go

The Go implementation was the fastest in this evaluation benchmark, 1.6 times (=160%) faster than the C implementation and 5 times (=4.8=160%/33%) faster than the Rust implementation. It seems that the best results were obtained by writing a straightforward program.

Python

As might be expected, the Python implementation produced the lowest results in this evaluation benchmark. The system (sys) time degraded by only 1/2 (=53%) compared to C, but the user (user) time performance is less than 1/100 (<1%), a characteristic of the interpreter execution since it is a pure Python implementation.

Conslusion

If I were to evaluate Go as the successor to C and from a Better C perspective, I would personally rank Go = (Objective-C) > Rust > C++. C++ is overspecified in terms of Better C, and Objective-C has stopped evolving since 2007 (2.0) when ARC was introduced. Swift, the supposed successor, also has an uncertain multi-platform future [23].

Regarding productivity, Rust is a language that generally requires a learning period before it feels productive [5]. It is a language that is both safe and fast [1], but due to its limitations, it is a language that forces a struggle with the compiler, both good and bad. If it does not follow Rust's semantics, it is not possible to bring in design patterns (experience) from other languages. However, its limitations make it a language that requires contending with the compiler, in both good and bad ways.

In terms of productivity, it is often desirable to use existing development assets rather than implementations that can be completed only in Rust, as in this evaluation. Interoperability of C/C++ language assets continues to be highly desired in Rust and is recognized as a major challenge [5] [25] [26] [4] [27]. While there are FFI generators such as rust-bindgen [27], they are not interoperable with existing assets, and the interoperability issue is a major barrier compared to C++, Objective-C, and Go, where interoperability with C is guaranteed at the language level and can be used simply by including header files. Interoperability issues will be a factor in the decision to adopt Rust.

In terms of design, Rust also has to bring in reference (Arc) and exclusion control (Mutex) semantics similar to the C/C++/Go languages in concurrency applications (with data sharing), and also has to avoid the semantic limitations of Rust's language specification, such as move and lifetime. There is no escape from the limitations of the Rust language specification, such as Move and Lifetime. As a result, the degree of programming flexibility is limited compared to other programming languages, and design and implementation trade-off decisions need to be made that have an impact on productivity and performance, as shown in the performance evaluation discussion in Evaluation (ii).

As for safety, Rust is a programming language that is ensured by static analysis and dynamic boundary checks. However, even in traditional C/C++, a wealth of static analysis tools (e.g. Clang Static Analyze) and dynamic analysis tools (e.g. Valgrind) can be utilised, so a comprehensive evaluation including peripheral tools will be necessary.

Finally, in the performance evaluation, issues were identified in the Rust, C, and Go implementations. In this evaluation, the Go implementation showed good implementation efficiency and stable performance. Go may be the safest candidate as a general-purpose option. In any case, we will investigate the performance issues of each language in more detail.