Fire Performance of Steel Reinforced Concrete (SRC) Structures

AbstractThis paper summarizes some of the recent research published on steel reinforced concrete (SRC) structures under or after exposure to fire. The contents include: 1) Fire resistance and post-fire behavior of SRC columns; 2) Fire performance of SRC column to beam joints, by adopting a loading sequence including initial loading, heating, cooling and post-fire loading; 3) Fire resistance and post-fire behavior of SRC composite frames

Generic Go to Go: Dictionary-Passing, Monomorphisation, and Hybrid

Go is a popular statically-typed industrial programming language. To aid the type safe reuse of code, the recent Go release (Go 1.18) published on 15th March 2022 includes bounded parametric polymorphism via generic types. Go 1.18 implements generic types using combination of monomorphisation and call-graph based dictionary-passing called hybrid. This hybrid approach can be viewed as an optimised form of monomorphisation that statically generates specialised methods and types based on possible instantiations. A monolithic dictionary supplements information lost during monomorphisation, and it is structured according to the program's call graph. Unfortunately, the hybrid approach still suffers from code bloat, poor compilation speed, and limited code coverage. In this paper we propose and formalise a new non-specialising call-site based dictionary-passing translation. Our call-site based translation creates individual dictionaries for each type parameter, with dictionary construction occurring in place of instantiation, overcoming the limitations of hybrid. We prove it correct using a novel and general bisimulation up to technique. To better understand how different generics translations approaches work in practice, we benchmark five translators, Go 1.18, two existing monomorphisation translators, our dictionary-passing translator, and erasure translator. Our findings reveal several suggestions for improvements for Go 1.18 -- specifically how to overcome the expressiveness limitations of generic Go, and improve compile time and compiled code size performance of Go 1.18.Comment: Full version of paper submitted to OOPSLA '2

Analysis of concrete-filled stainless steel tubular columns under combined fire and loading

[EN] In fire scenarios, concrete-filled stainless steel tubular (CFSST) columns undergo initial loading at ambient temperature, loading during the heating phase as the fire develops, loading during the cooling phase as the fire dies out and continual loading after the fire. CFSST columns may fail some points during this process under combined fire and loading. In this paper, the failure modes and corresponding working mechanism of CFSST columns subjected to an entire loading and fire history are investigated. Sequentially coupled thermal-stress analyses in ABAQUS are employed to establish the temperature field and structural response of the CFSST column. To improve the precision of the finite element (FE) model, the influence of moisture on the thermal conductivity and specific heat of concrete during both the heating and cooling phases is considered using subroutines. Existing fire and post-fire test data of CFSST columns are used to validate the FE models. Comparisons between predicted and test results confirm that the accuracy of the FE models is acceptable; the FE models are then extended to simulate a typical CFSST column subjected to the entire loading and fire history. The behaviour of the CFSST column is explained by analysis of the temperature distribution, load versus axial deformation curves and failure response.The research reported in the paper is part of the Project 51308539 supported by the National Natural Science Foundation of China. The financial support is highly appreciated.Tan, Q.; Gardner, L.; Han, L.; Song, D. (2018). Analysis of concrete-filled stainless steel tubular columns under combined fire and loading. En Proceedings of the 12th International Conference on Advances in Steel-Concrete Composite Structures. ASCCS 2018. Editorial Universitat Politècnica de València. 825-833. https://doi.org/10.4995/ASCCS2018.2018.7206OCS82583

Matrine Reverses the Warburg Effect and Suppresses Colon Cancer Cell Growth via Negatively Regulating HIF-1α.

The Warburg effect is a peculiar feature of cancer’s metabolism, which is an attractive therapeutic target that could aim tumor cells while sparing normal tissue. Matrine is an alkaloid extracted from the herb root of a traditional Chinese medicine, Sophora flavescens Ait. Matrine has been reported to have selective cytotoxicity toward cancer cells but with elusive mechanisms. Here, we reported that matrine was able to reverse the Warburg effect (inhibiting glucose uptake and lactate production) and suppress the growth of human colon cancer cells in vitro and in vivo . Mechanistically, we revealed that matrine significantly decreased the messenger RNA (mRNA) and protein expression of HIF-1α, a critical transcription factor in reprogramming cancer metabolism toward the Warburg effect. As a result, the expression levels of GLUT1, HK2, and LDHA, the downstream targets of HIF-1α in regulating glucose metabolism, were dramatically inhibited by matrine. Moreover, this inhibitory effect of matrine was significantly attenuated when HIF-1α was knocked down or exogenous overexpressed in colon cancer cells. Together, our results revealed that matrine inhibits colon cancer cell growth via suppression of HIF-1α expression and its downstream regulation of Warburg effect. Matrine could be further developed as an antitumor agent targeting the HIF-1α-mediated Warburg effect for colon cancer treatment

Toddler: Detecting Performance Problems via Similar Memory-Access Patterns

Abstract—Performance bugs are programming errors that create significant performance degradation. While developers often use automated oracles for detecting functional bugs, detecting performance bugs usually requires time-consuming, manual analysis of execution profiles. The human effort for performance analysis limits the number of performance tests analyzed and enables performance bugs to easily escape to production. Unfortunately, while profilers can successfully localize slow executing code, profilers cannot be effectively used as automated oracles. This paper presents TODDLER, a novel automated oracle for performance bugs, which enables testing for performance bugs to use the well established and automated process of testing for functional bugs. TODDLER reports code loops whose computation has repetitive and partially similar memory-access patterns across loop iterations. Such repetitive work is likely unnecessary and can be done faster. We implement TODDLER for Java and evaluate it on 9 popular Java codebases. Our experiments with 11 previously known, real-world performance bugs show that TODDLER finds these bugs with a higher accuracy than the standard Java profiler. Using TODDLER, we also found 42 new bugs in six Java projects: Ant, Google Core Libraries, JUnit, Apache Collections, JDK, and JFreeChart. Based on our bug reports, developers so far fixed 10 bugs and confirmed 6 more as real bugs. I

Understanding and detecting real-world performance bugs

Developers frequently use inefficient code sequences that could be fixed by simple patches. These inefficient code sequences can cause significant performance degradation and resource waste, referred to as performance bugs. Meager increases in single threaded performance in the multi-core era and increasing emphasis on energy efficiency call for more effort in tackling performance bugs. This paper conducts a comprehensive study of 109 real-world performance bugs that are randomly sampled from five representative software suites (Apache, Chrome, GCC, Mozilla, and MySQL). The findings of this study provide guidance for future work to avoid, expose, detect, and fix performance bugs. Guided by our characteristics study, efficiency rules are extracted from 25 patches and are used to detect performance bugs. 332 previously unknown performance problems are found in the latest versions of MySQL, Apache, and Mozilla applications, including 219 performance problems found by applying rules across applications

Automated atomicity-violation fixing

Fixing software bugs has always been an important and timeconsuming process in software development. Fixing concurrency bugs has become especially critical in the multicore era. However, fixing concurrency bugs is challenging, in part due to nondeterministic failures and tricky parallel reasoning. Beyond correctly fixing the original problem in the software, a good patch should also avoid introducing new bugs, degrading performance unnecessarily, or damaging software readability. Existing tools cannot automate the whole fixing process and provide good-quality patches. We present AFix, a tool that automates the whole process of fixing one common type of concurrency bug: single-variable atomicity violations. AFix starts from the bug reports of existing bugdetection tools. It augments these with static analysis to construct a suitable patch for each bug report. It further tries to combine the patches of multiple bugs for better performance and code readability. Finally, AFix’s run-time component provides testing customized for each patch. Our evaluation shows that patches automatically generated by AFix correctly eliminate six out of eight real-world bugs and significantly decrease the failure probability in the other two cases. AFix patches never introduce new bugs and usually have similar performance to manually-designed patches