Optimal heap limits for reducing browser memory use

One major problem of using Java in real-time and embedded devices is the non-deterministic turnaround time of dynamic memory management systems (memory allocation and garbage collection). For the allocation, the nondeterminism is often contributed by the time to perform searching, splitting, and coalescing. For the garbage collection, the turnaround time is usually determined by the size of the heap, the number of live objects, the number of object collected, and the amount of garbage collected Even with the current state-of-the-art garbage collectors (generational and incremental schemes), they may or may not guarantee the worst case latency. Moreover such schemes often prolong overall garbage collection time. In this paper, the performance analysis of the proposed Active Memory Module (AMM) for embedded systems is presented Unlike the software counterparts, the AMM can perform a memory allocation in a predictable and hounded fashion (14 cycles). Moreover it can also yield a bounded sweeping time regardless of the number of live objects or heap size. By utilizing the proposed system, the overall speed-up can be as high as 23% over the JDK 1.2.2 running in classic mode.

The growing adoption of deep learning in medical image processing requires careful consideration of energy usage during model training. This study investigates the impact of batch size and training epochs on energy consumption during the fine-tuning of ResNet-50, a widely used convolutional neural network. The experiments were conducted on the ODIR-5K ocular disease dataset, using a controlled hardware configuration with GPU-level monitoring to ensure reproducibility. Fine-tuning was performed with batch sizes of 32, 64, 128, and 256 across four epoch schedules: 1, 10, 80, and 160. For each configuration, training time, average power draw, total energy consumption, GPU utilization, and memory usage were recorded. The results show that the number of epochs is the dominant factor influencing energy consumption, as training time and total energy scale almost linearly with epoch count. Batch size, in contrast, introduced a more complex trade-off. Larger batches reduced the average power drawn by the GPU but significantly increased training time, leading to higher overall energy consumption. Additionally, GPU utilization decreased as batch size increased, suggesting reduced hardware efficiency, while memory usage rose with larger batches. These findings highlight the importance of jointly considering batch size and epoch count when optimizing training configurations. Simply reducing instantaneous power draw does not guarantee lower total energy consumption. The results provide empirical evidence that can inform more energy-aware strategies in deep learning, particularly in medical imaging tasks where both computational efficiency and sustainability are critical.

With the ever-growing use of the Internet in our daily lives, an increase of potentially sensitive data being shared and accessed online is observed. Web apps and browsers are the main tools used by Internet users, so being able to guarantee secure browsing is a key point. In this context, this paper explores key aspects of web security and privacy in two of the most widely used browsers worldwide - Google Chrome and Microsoft Edge, running in different operating systems - Windows and Linux. Whilst emulating a browsing routine of a common web user for navigating through heterogeneous services, the aim is to verify if the content being shared online is properly secure. For this purpose, a comparative analysis based on collected web-browsing traffic, protocols in use, cookies and related policies is carried out, being the main browsers’ vulnerabilities identified and discussed.

Although a data processing system often works as a batch processing system, many enterprises deploy such a system as a service, which we call the service-oriented data processing system. It has been shown that in-memory data processing systems suffer from serious memory pressure. The situation becomes even worse for the service-oriented data processing systems due to various reasons. For example, in a service-oriented system, multiple submitted tasks are launched at the same time and executed in the same context in the resources, compared with the batch processing mode where the tasks are processed one by one. Therefore, the memory pressure will affect all submitted tasks, including the tasks that only incur the light memory pressure when they are run alone. In this paper, we find that the reason why memory pressure arises is because the running tasks produce massive long-living data objects in the limited memory space. Our studies further reveal that the long-living data objects are generated by the API functions that are invoked by the in-memory processing frameworks. Based on these findings, we propose a method to classify the API functions based on the memory usage rate. Further, we design a scheduler called MURS to mitigate the memory pressure. We implement MURS in Spark and conduct the experiments to evaluate the performance of MURS. The results show that when comparing to Spark, MURS can 1) decrease the execution time of the submitted jobs by up to 65.8%, 2) mitigate the memory pressure in the server by decreasing the garbage collection time by up to 81%, and 3) reduce the data spilling, and hence disk I/O, by approximately 90%.

Agricultural insurance is one of the formal and reliable risk management instruments to cope with agrarian risks. Presently, agricultural insurance products rely heavily on centralized systems that lack transparency and traceability, leading to suboptimal risk assessment and delays in payouts. To address these concerns the fintech industry has started to embrace a popular decentralized technology called blockchain. However, blockchain operates as a deterministic and synchronized state system, which means it cannot directly access real-world data for decentralized applications. A mechanism called oracle is required for the trusted access of agricultural risk factor data to smart contracts from external sources such as Internet of Things (IoT) devices, web services and databases. Hence, the present study proposes a blockchain-based AgriInsureDON framework with a privacy-preserving decentralized oracle for risk factor data access from trusted IoT devices for agricultural insurance. Initially, a method for computing the direct reputation score of IoT devices based on behavioral and data reputation is illustrated. Next, a privacy preserved decentralized oracle mechanism is designed and implemented using a masked secret sharing and secure aggregation scheme. Later, we demonstrate the working of weather-indexed insurance contracts based on decentralized oracle. Finally, a performance analysis of smart contract transactions w.r.t average latency, throughput, average CPU utilization and total memory usage is conducted on Ganache and Sepolia test networks. The evaluation results of privacy-protected decentralized oracle and an indexed insurance contract within AgriInsureDON framework confirms that transactions are efficient and scalable to meet the requirements of expedited claim settlement.

A large number of methods for simulating reactive flows exist, some of them, for example, directly use detailed chemical kinetics or use precomputed and tabulated flame solutions. Both approaches couple the research fields computational fluid dynamics and chemistry tightly together using either an online or offline approach to solve the chemistry domain. The offline approach usually involves a method of generating databases or so-called Lookup-Tables (LUTs). As these LUTs are extended to not only contain material properties but interactions between chemistry and turbulent flow, the number of parameters and thus dimensions increases. Given a reasonable discretisation, file sizes can increase drastically. The main goal of this work is to provide methods that handle large database files efficiently. A Memory ion Layer (MAL) has been developed that handles requested LUT entries efficiently by splitting the database file into several smaller blocks. It keeps the total memory usage at a minimum using thin allocation methods and compression to minimise filesystem operations. The MAL has been evaluated using three different test cases. The first rather generic one is a sequential reading operation on an LUT to evaluate the runtime behaviour as well as the memory consumption of the MAL. The second test case is a simulation of a non-premixed turbulent flame, the so-called HM1 flame, which is a well-known test case in the turbulent combustion community. The third test case is a simulation of a non-premixed laminar flame as described by McEnally in 1996 and Bennett in 2000. Using the previously developed solver ‘flameletFoam’ in conjunction with the MAL, memory consumption and the performance penalty introduced were studied. The total memory used while running a parallel simulation was reduced significantly while the CPU time overhead associated with the MAL remained low.

This study presents an improved technique for obtaining the collapse loads for any geotechnical stability problem with the application of the lower bound finite elements limit analysis in combination with linear programming. In the proposed method, a lower order polygon is initially used throughout the problem domain to model the Mohr–Coulomb yield function; the order of the polygon refers to its total number of sides. After obtaining the initial solution, the problem domain is then discretized into a number of zones in which a different order polygon is used to model the yield surface. It is noted that a higher order polygon needs to be chosen only in a region, not everywhere, where the stress state approaches towards the yield. The total memory usage as well as the computational time needed to solve the problem with the proposed technique becomes significantly smaller. In order to check the validity of the method, the bearing capacity factor Nγ was computed for smooth as well as rough strip footing and the obtained computational results were found to be quite encouraging.

The worldwide Web has dramatically evolved in recent years. Web pages are dynamic, expressed by programs written in common programming languages given rise to sophisticated Web applications. Thus, Web browsers are almost operating systems, having to interpret/compile such programs and execute them. Although JavaScript is widely used to express dynamic Web pages, it has several shortcomings and performance inefficiencies. To overcome such limitations, major IT powerhouses are developing a new portable and size/load efficient language: WebAssembly.In this paper, we conduct the first systematic study on the energy and run-time performance of WebAssembly and JavaScript on the Web. We used micro-benchmarks and also real applications in order to have more realistic results. Preliminary results show that WebAssembly, while still in its infancy, is starting to already outperform JavaScript, with much more room to grow. A statistical analysis indicates that WebAssembly produces significant performance differences compared to JavaScript. However, these differences differ between micro-benchmarks and real-world benchmarks. Our results also show that WebAssembly improved energy efficiency by 30%, on average, and showed how different WebAssembly behaviour is among three popular Web Browsers: Google Chrome, Microsoft Edge, and Mozilla Firefox. Our findings indicate that WebAssembly is faster than JavaScript and even more energy-efficient. Additionally, our benchmarking framework is also available to allow further research and replication.

Chracer: Memory analysis of Chromium-based browsers

Heterogeneous multiprocessors are emerging as the dominant implementation approach to embedded multiprocessor systems. In addition to having processing elements suited to the target applications, these systems will also have custom memory and bus architectures. Because of performance and cost constraints, these systems must be carefully designed to balance system partitioning and resource sharing. The sheer size of the design space requires that tools be able to do this balancing. We have developed an augmented simulated annealing synthesis tool that uses system performance and layout evaluation to drive simultaneous data mapping, memory allocation and bus synthesis. Exploring these optimizations at the same time, our approach reverses traditional techniques and determines bus topology first rather than last, thereby exposing a larger design space and taking advantage of cost-saving resource sharing unavailable to previous approaches that allocate memories first. This results in 20% cost reduction for high-performance designs as well as 27% for low-cost designs in comparison with an approach that performs memory allocation and data mapping separately from bus synthesis.

The performance of memory allocation operations significantly impacts the global performance in most computing applications. Thus, the choice of a memory allocator is an important aspect when projecting more sophisticated computing systems. The strong correlation between the dynamic memory use profile and the allocator performance requires the allocator to be chosen through an experimental study. This research carried out an exploratory study on a set of six widely used memory allocators: Ptmalloc2 (standard glibc allocator), Ptmalloc3, Hoard, Miser, TCMalloc, and Jemalloc. The workloads used to evaluate the allocators were based on a characterization study on memory use of seven application, two of which for servers and five for desktops. Each allocator was evaluated regarding its response time and memory usage in a set with 648 different execution scenarios. The results showed that the allocators with the shortest mean execution time also made the best use of parallelism in scenarios with more than one thread and one processor. The allocators Jemalloc and TCMalloc were, on average, five times faster than the standard glibc allocator. Under certain conditions, the allocator Hoard provided substantial memory savings of up to 75% when compared with the other allocators assessed. These results emphasize the importance of allocator choice when projecting applications in face of the significant differences observed experimentally in this study.

Document stores have become one of the key NoSQL storage solutions. They have been widely adopted in different domains due to their ability to store semi-structured data and expressive query capabilities. However, implementations differ in terms of concrete data storage and retrieval. Unfortunately, a standard framework for data and query optimization for document stores is nonexistent, and only implementation-specific design and query guidelines are used. Hence, the goal of this work is to aid automating the data design for document stores based on query costs instead of generic design rules. For this, we define a generic storage and query cost model based on disk access and memory allocation that allows estimating the impact of design decisions. Since all document stores carry out data operations in memory, we first estimate the memory usage by considering characteristics of the stored documents, their access patterns, and memory management algorithms. Then, using this estimation and metadata storage size, we introduce a cost model for random access queries. We validate our work on two well-known document store implementations: MongoDB and Couchbase. The results show that the memory usage estimates have the average precision of 91% and predicted costs are highly correlated to the actual execution times. During this work, we have managed to suggest several improvements to document storage systems. Thus, this cost model also contributes to identifying discordance between document store implementations and their theoretical expectations.

The capacity and reliability of biological memory could be exceeded by a constantly growing flux of information to remember and operate by. Yet, our memory is fragile and could be easily impaired, and the prevalence of memory disorders is increasing in correlation with the population's mean age. As expected, auxiliary memory devices (such as writing pads and computers) are abundant but are operated indirectly using significant effort compared with biological memory. We report a working prototype of a simplified, 4 KB random-access memory (RAM) that can be written to or read from using thought and could be embedded more seamlessly than other artificial memory aids. The system analyses EEG signals to extract attention levels, which trained subjects can use to write messages into an RFID sticker, or read from it on a display. We describe basic modes of using memory by a single subject, emulate common forms of social communication using this system, and highlight new forms of social usage and allocation of memories that are linked to specific persons. This preliminary prototype highlights the technical feasibility and the possibilities of implantable thought-operated memory devices and could be developed further to provide seamless aid to people suffering from memory disorders in the near future.

The Warren abstract machine (WAM) has become a generally accepted standard Prolog implementation technique. Garbage collection is an important aspect in the implementation of any Prolog system. A synopsis of the WAM is presented and then marking and compaction algorithms are shown that take advantage of WAM's unique use of the data areas. Marking and compaction are performed on both the heap and the trail; both use pointer reversal techniques, which obviate the need for extra stack space. However, two bits for every pointer on the heap are reserved for the garbage collection algorithm. The algorithm can work on segments of the heap, which may lead to a significant reduction of the total garbage collection time. The time of the algorithms are linear in the size of the areas.

We develop and examine job migration policies by considering effective usage of global memory in addition to CPU load sharing in distributed systems. When a node is identified for lacking sufficient memory space to serve jobs, one or more jobs of the node will be migrated to remote nodes with low memory allocations. If the memory space is sufficiently large the jobs will be scheduled by a CPU-based load sharing policy. Following the principle of sharing both CPU and memory resources, we present several load sharing alternatives. Out objective is to reduce the number of page faults caused by unbalanced memory allocations for jobs among distributed nodes, so that overall performance of a distributed system can be significantly improved. We have conducted trace-driven simulations to compare CPU-based load sharing policies with our policies. We show that our load sharing policies not only improve performance of memory bound jobs, but also maintain the same load sharing quality as the CPU-based policies for CPU-bound jobs. Regarding remote execution and preemptive migration strategies, our experiments indicate that a strategy selection in load sharing is dependent on the amount of memory demand of jobs-remote execution is more effective for memory-bound jobs, and preemptive migration is more effective for CPU-bound jobs. Our CPU memory-based policy using either high performance or high throughput approach and using the remote execution strategy performs the best for both CPU-bound and memory-bound jobs.