So, hello everyone, today I am going to talk about how we introduced analytics in Sousa skill CMS. So, I have mentioned my GitHub and Twitter handle there, so please feel free to reach out to me. So, the agenda for today would be to first I will give you a brief about me and then I will give you a brief about the entire Sousa architecture like what is Sousa and what are the several components and how everything is working. So, after that we will look into React, what React is and how we use React to develop our UI solutions for Sousa and how it helped us to create really amazing web solutions. After that we will get into the Sousa skill CMS which is a branch of the Sousa web projects.  And after that we will get into how we introduce analytics in the CMS. So, the skill creators and the users of the skill can get more analytical details about how the skill is performing and all that stuff. So, let's get started. So, first I will give you a brief about me. So, I am a pre-funneling undergraduate student from Tripoli, Vododra, India and I am presently pursuing computer science. So, I started with software development in 2016 because I had a course where I had to create a web project and then I started exploring various web aspects like HTML, CSS, JavaScript. So, I created a really basic web project and then I started learning about Git and GitHub and what it is and how it works. That was really interesting and I was really fascinated about the entire ecosystem, the web development ecosystem. So, I continued with the web development after that and that was also the time when I started doing open source and I created some basic projects of my own and then I started contributing to various organizations as well. So, Fossature was one of them and the projects were really easy to get started with. So, I started contributing, first I started with really basic contributions like updating documentation and fixing some really basic UI bug like that can be just fixed using some CSS. So, I started with that and then eventually my contributions go over and the quality also increase. So, that was really nice and that was a real learning experience for me because that is from where I evolved and got professional in the web development. So, in 2016 when I got into my university, I started exploring several programming languages and domains of programming. So, web development was really interesting as I said and I also really like JavaScript. So, I started exploring the JavaScript ecosystem. So, and I learned that there was a lot to the JavaScript ecosystem. So, React was also really coming up at that time. So, I started learning React as well and then I contributed to several open source projects in Fossature. I became a code and I also participated in a contest called Hoodit by Fossature in 2017. So, I also emerged as a finalist, so that was really exciting. And then I got into GSO getting with Fossature last year. So, my project was to introduce analytics in the CMS and I worked with in a team of three. So, my team members were Rakshad Gag and Anupan Var. And all three of us worked into analytics part. So, we handled everything from server to the front end and all of the analytics. And I really enjoy anime and football as well. I really pursue my free time. So, my journey with Fossature started with really great projects that easy to get started with. So, I found repositories and then I used to set them and then used to understand the code base. And then that got me really interested in it. And so, I actually become a member of various programs that Fossature has. So, I participated in CodeHeat, I participated in G-SIM, and then I participated in GSO finally last year. The thing was for the admin side, they are all able to help me to face in the community. So, it's really common that he can play some setting up issues in my face. So, the mantis are always available in the Gita channel. We have dedicated the channel for all the projects. So, people can just reach out there and there's no, I mean, watching system or anything like that. You can, if you want to just get started, you can just join the Gita channel, open an issue and open a pill request to just start your contribution. So, that is really easy and amazing. So, let's talk about SoC now. So, SoC is basically a web framework, a framework to develop conversational solutions. So, the great thing about SoC is that it's open and you can create your solutions on any platform. So, we have platforms developed on our own. So, we have web clients, several web clients. We have mobile apps, we have bots, and then we have the smart speaker, that is the SoC hardware. So, the server is basically the entire brain of SoC. So, we have several clients, like web clients, web apps, bots, all the clients communicate to the server via REST API. So, the server exposes REST API endpoints. So, the clients can just talk to the server. So, this is the entire wireframe about how everything's working. So, as you can see, this is the brain, which is the server that we have hosted online. And then we have all these clients, which can talk to the server via an API request. And we have users who can just send a query via any client and then talk to the server using that. So, we have all other, setting a personalization and user data that is oriented for the user. So, and then here we have the skills CMS, and here we have skills. So, what basically a skill is, skills are something that is aggregated by the community. So, the community works to gather skills, and skills is something that SoC uses to respond to the user. So, if you want to create a weather skill, so you can just create a weather skill, and then you'll be able to ask SoC about what's the weather today. But we have a weather skill, so I'm just giving an example. But if you want, like, the SoC didn't have any skill to recommend an anime, so the skill to recommend an anime is, and yeah, that was it. So, it's really community oriented, so because open source is really driven by the community, and it takes a huge community effort to sustain open source. So, if you want to improve any skill, you can just go to the skills CMS, register there, and then you can edit any skill as per your wish. So, that is really amazing, and that also makes sure that all of the skills are fine tuned and they perform well. So, let's talk about React now. So, how many of you already know, or heard of it? Okay, so how many of you have heard it before this? Okay, yeah, nice. So, React is a JavaScript library for building user interfaces by Facebook, so. And the catch is that React is not a framework, because many people have a misconception that React is a framework, but React is a library, as Facebook says. So, it follows a component-based pattern, so everything in React is a component, basically. So, you can just compose components, and then you can create a UI solution as per your wish. And React does the hard parts of managing state for your application, so you just have to focus on a UI, and then it will handle automatically to update and handle the DOM tree. So, React makes it really simple to create UI solutions, and it's really accessible, and it's really easy to get started with as well. So, another question that you may have is, why did you choose React? You wanted to try new things, firstly, because by the time we started with Sushi Web Projects, we already had projects in Angular and EmberJS. So, React was really emerging at that time, and it was really popular, and we thought, why not let's just start the Sushi Apps family in ReactJS, and we also had contributors, great contributors at that time, so they were also really excited for choosing React as a web framework for this. So, another some highlights that React has is, it has easier state management for your application. So, manage your state really efficiently, and then we have helper libraries, libraries like Redux and Flux as well. So, Redux is basically like you have a centralized store for your application, so all of the data in an application is stored in a centralized store, and anywhere the data from the store is used. So, if any component updates the store in the data, it will be updated throughout your DOM tree. So, that is really amazing. So, it also facilitates code sharing and code splitting. So, because many people already have, so what you can do is you can just create a React component, and then you can put it anywhere and it will work the same throughout any application that you use. So, I've published a few React components on my own as well like they are really basic components, but yeah that's how it is. And we also have several UI libraries which offer great React components. So, what you can do is you can just import that library and then you can use the components from that library. So, that is really cool. So, let's get into what Suci Web projects are. So, all of the Suci Web projects are in React. We have three web clients that we started some years back. The first is the chat application that is basically a chat window that you can use to interact with Suci and then you can just shoot in your queries to the Suci server and then Suci will reply you appropriately. That we have the CMS. So, it allows you to manage skills that the Suci server uses and then it allows you to manage and create bots as well. And then it also allows you to get the analytics about your skills. So, you can know how many users your skill has and how like we have the rating system as well. And how many people are using it in various countries and what is your skills done. So, all that analytics is also developed at the CMS. After that we have the accounts web app which is it also basically handles stuff related to your account. So, in Suci you can just register your account then you can manage your account from the accounts web app. So, these are the three web apps that we started for Suci. So, let's get into CMS. So, the CMS basically comprises of three things that is skills management, bots management and then it also provides you the analytics there. So, the workflow for how we use the server to hook up our frontend is that we have current APIs on the server for various things like you can we have APIs for authentication, we have APIs for getting a skill, we have APIs for sorting stuff and searching stuff. All that APIs are available on the Suci server. So, what we can do is we just import relevant components from the material UI library. So, we are using material UI right now but we are looking to port to our own components. So, we just import components from the material UI library. We place them in the UI appropriately like how we want to as per the design spec. We just place them in the UI, we check responsiveness and fix all of the styling issues that we have and then we just call the API from the server, we fetch our data and then we input all of this data into our component. So, that's how the frontend and the server is connected. So, basically the UI components that live on the frontend consume data from the restful APIs that are exposed on the backends. And API is written in JSON standard, JSON response with the requested data and then this data is brought into the components. So, JSON is just a response format and some people use XML as well but I don't know the advantage of that but okay. So, let's look at example. This is, this URL is a sample API called to the server. So, if you just visit this URL, you'll get this kind of JSON response. So, this JSON response has key called skill rating then it has a key called stars and then all of the stars are distributed in this fashion. So, one star, two star, three star. So, this is for getting data for any skill. So, you just get the metadata for any skill. You get the skill rating in that data as well. So, this is just a sample of that. So, this is how we data from the server and then we just use this JSON data in the frontend to fill in to the components. And for the request library we're using, we recently coded to Axios. So, and on the frontend once we have the data we are using a library called recharts right now which provides charting solutions for as many as kind of stars like pie chart, bar chart, line chart and all that stuff. So, this is how the basic architecture looks like. We, for the ratings we have using bar chart. So, we just import bar chart from recharts library and then while in the render function we just return this JSX, this renders a bar chart component from the recharts. We fill in the data which is equal to the ratings data that we fetched earlier and then we just close this JSX style. So, this is the basic workflow about how everything's working, we fetch the data, we fetch the UI components from the library is that we're using and then we just hook all of this data together. So, our app is rendered in that way. So, let's get a quick insight into our code base. So, this is the suci-skill CMS code base and all this is majorly documentation. The main thing is the source folder which has tests that contain the tests for our UI. It has the API folder which mainly handles all of the API calls that we have. So, as I said before, it has various API calls for authentication, for fetching your skills, for rating and all that stuff. So, after that we have the components folder. So, this basically contains all of our UI components that we are using in our UI. And after that we have a helper folder which contains all of our helper files. It has files for checking email, it checks your phone number and all that stuff. After that we have images that we are using on our front end. We have a redux folder. So, we recently put it to redux because the app was getting really used and the code base was really getting complicated. So, it was really difficult for new contributors to get started with. So, we recently put it to redux.


Hi, my name is Pisri, working at Hyundai Motor Company. In this talk, I'm going to introduce Guider Unified Runtime Performance Analyzer and explain how to analyze automotive and front-end motor system using it. This is a summary for my talk. First, talking about performance analysis and optimization. Next, introducing Guider and its useful features. And next, explaining how to analyze automotive and front-end system using it. Finally, showing demo how to use Guider. Software development eventually lead to code changes. Changed code introduces new bugs and makes working code meaningless, causes unnecessary communication between tasks and requires new optimizations. For new platform development and continuous update, we constantly create change and delete code, but we are not very sensitive to the performance degradation caused by the change. And if these changes are accumulated, the code is modified very significantly to improve the deteriorated performance. It's a mixture cycle that repeats. Therefore, we always need to manage, analyze, and improve performance more systematically. Let's talk about performance factors. First of all, the major performance factor is CPU. There are many reasons make your system slow such like a CPU intensive job, pre-country context switching, very busy way tasks, and so on. If your system is slowing down, the first thing to do is watching total CPU uses and which tasks are using CPU cores. Memory is also important. Frequent memory allocation and deallocation jobs will consume CPU more than expected. And in efficient allocation and missing deallocation such like lakes can cause the out of memory, then system will be slow seriously. In worst case, it will restart finally. To free on memory, Linux kernel tried to flush file caches, swap pages out, it called reclaimed. Once reclaimed start, the system will slowly start to slow down. Next one is IEU. Generally, block device is the slowest in our system. So, optimization such like caching, reloading, completion, workload tuning is required. Especially on necessary IEU operations should be removed and continuous operations must be merged. Last one is the communication. Lock, it's very important to prevent data collection shared between multiple tasks but it can have a huge impact on performance. Accessible lock contention increases CPU uses and also response time. Moreover, performance can be worse depending on lock attributes such like priority inheritance protocol, vis-a-vis wake up strong in few takes. IPC, in the modern system, all services generate framework procedure call using system burst such like DevOps to avoid in complex relationship with each other. But this RPC may cause system overheads such like context switching, serialization, memory copy. In particularly, broadcasting calls could actually increases the system load and response time. IRQ, especially software interrupts called bottom heart can affect system response time. Network drivers are typical so it has many performance tuning options between CPU uses and response time. It's about trade off. In addition to these factors I described, there are many other performance factors. Most importantly, we need to be able to recognize each performance factor and measure its actual impact. Yes, we need to think about how to measure them. Logging and using tools are most effective way to analyze performance. Logging is values for recording specific information but understanding log requires non-n-specific knowledge so system-level engineers or new members difficult to understand them usually. In addition, adding new logs requires some search code and tool chain for rebuild. It's very boring and time-consuming. It's also difficult to record and analyze too many logs because of the limitation for memory and our time. So we prefer to use performance tools. It's very comfortable and effective to analyze performance at system level. Some nice tools doesn't even require rebuilding target program and installing itself with dependent packages restarting target tasks. But sometimes too many tools confuse us determining the right tool from a variety of performance issues is not easy. So I introduce Guider Unified Runtime Performance Analyzer. It can monitor, profile, trace, visualize various performance factors. Monitoring features provide continuous performance stats every interval in real time. Profiling features provide a statistic overview of collected data during a specific interval. Tracing features provide specific data on the execution of the task in the form of logs. Guider is a kind of client command line interface tool so it offers a lot of features by the combination of commands and options. But in this talk, I will try to explain only some useful features and tracing features about it because of the time limitation. It's open source program and written in Python. It doesn't require installation but PIP and OE, Yachto recipe also supported for your convenience. Actually just executing Guider.py file is enough. Guider never use external binaries such like executable programs. Packages accept for metplot library for some kind of visualization features. Most of guide features are implemented directly using standard libraries such like Lipsy. That's the reason why Guider doesn't require rebuild and install configuration. In addition, it can be applied with only one megabyte of storage space. These characteristics are very attractive in embedded system, especially. All features of Guider are supported in Linux and Android and it also provides some limited features on Mac OS and Windows. So from now, let me introduce some carrying features of Guider. First one is monitoring system resources in real time. This feature works by periodically updating states for system resource and events. System resources of CPU, memory swap, block, network storage. As shown in the picture, in the first part system resource information is shown on the timeline such as the number of cores, RAM, and swap. And additional system information such as context switching, interrupt, running task, memory zone, performance stats using PMU also displayed. In the second part, important system-level resources and events are printed. System states such as CPU uses of valuable memory, swap uses, memory decline, lab IO, and drug IO also features information for performance analysis. In addition, core usage is also printed. Although not shown in this picture, governor, clock, temperature for each core can be shown together using specific options. In the third part, storage and information about busy workload of developed space is shown for each device. Having storage workload can cause serious performance degradation. That's the reason why we tracked those stats. In the upper part of the picture, network information about inbound and outbound is shown for each device. In the lower part of the picture, not only system resources, but also task resources that are shown with their attributes in real time. It's a little bit similar to Reynolds top comment. Usages for CPU, virtual physical shared memory, swap, block IO, and memory details are printed well. The shown tasks are sorted by CPU usage by default, but you can change the search order using a specific option. The task filter is also available to show on the specific tasks. All or specific function calls are monitored for a specific task in real time. In addition, tasks about function calls are also printed such as average, minimum, maximum time. At this picture, all function calls are shown with that trace. That usage is not about CPU, it's the proportion for the total function calls. So this picture is useful when finding frequent calls or measuring specific function call counts, including backtrace. Of course, there is another function monitor feature to measure CPU intensive function calls by sampling techniques. The task filter and function filter are also supported. All system calls including backtrace are also monitored for a specific task in real time. In addition, these call states are also shown such as allowed time, error return together. This feature is values for when finding these calls that take a long time, measuring specific Cisco count, checking Cisco error returns. The task filter and Cisco filter are also supported. All of the files, sockets, pipes are monitored for each process in real time. Files are printed with position and open flag. TCP and UDP sockets are printed with binding and connection status. Units domain sockets are also printed with the file pass. This kind of information is very precious when debugging issues or performance tracing. The process filter and the file filter are also available by using the file filter, monitoring all processes that open specific files or binding specific sockets is possible. Precise monitoring features are for checking current status, but if someone want to see a summary of system changes for a long time, the profiling features can be good solutions. As shown in the picture in the top table, changes for system resources and events are printed for each interval. CPU uses available memory block IO swap uses, memory claim size, running task, native uses summarized in each line for each interval. Because of screen length limitation, some fields were truncated. In the middle table, changes for storage uses displayed with total summary. There was no storage operation in the profiling time. Busy, workload size, available space summarized for each time interval for each device. In the bottom table, changes for network uses are printed with total summary in the red box. Workload for inbound and outbound is summarized for each time interval for each device. Next profiling features are for tasks. In the first table, changes for pop process CPU uses are shown in task attributes and total summary for each interval. Total summary information in the red box reflects and CPU uses such as minimum, average, maximum, and total for each task and whole system. In the second table, changes for pop process virtual memory uses are printed with task attributes and total summary for each interval. The overall format is similar to the CPU table above. Although not shown in this picture, various types of tables are reported together such like scheduling delay, physical memory, block IU, signal uses. By using these features, measuring and comparing resource uses are possible for various test cases. Next feature is for comparing performance between different versions of software. This feature makes it easy to analyze changes in resources such as CPU, GPU, and memory due to version changes. Each resource is largely divided into system and task unit uses and resource usage statistics provided as mean, average, max, and total. Text-based analysis is specific but less readable. That's why it provides visualization features in SVG format. Using the SVG format offered in your web browser, it provides easy to view the responsive interface. First visualization feature is about resource graph. As shown in the picture, the top box shows graphs of CPU uses for processes. The box on the right side is the label list for the CPU graphs. The middle box shows graphs of block network IU for the whole system. The bottom box shows graphs of memory for the whole system. Of course, process graphs about block network memory resources are also available. In addition, filter option for all of them is also supported. As shown, as you can see, this visualization feature makes it easy to understand big data collected for a long time. And it also helps to understand trends in resource uses. This is also good for communication with other people. Next visualization feature is about scheduling. The scheduling data is very large and very difficult to analyze one by one. Therefore, as shown in the picture, scheduling data such as time slice preemption and blocking should be visualized prior to a detailed analysis. Using SVG format output in your web browser, you can view details for time slices. It's very effective for analyzing multi-threaded programs interactive services, delayed tasks, core utilization. In addition, this feature also allows for scheduling events as well as other custom events having time stamps for start and end. Last visualization feature is about call stacks. Analyzing only last called functions without who on call stack is difficult because standard functions such like read and write can be called by any other functions. Above all, in most cases, last called functions will not cause all the problems. The problem is likely some other functions that called those last functions. Therefore, to analyze performance problems in function level, we need to able to see the who including each call stack. In this case, this prime graph features values to analyze call stack-based profiling result for CPUs, blocking status, memory leak, Cs call trigger, function call. As shown in the picture, last functions at the bottom of each stack are various. So we need to analyze upper functions that contains them. I guess modifying those functions will improve your application or service performance actually. Opening the SBZ format output in your web browser, highlighting and joining or searching specific functions or stacks are also available using mouse and keyboard. Okay, so far I have introduced some useful features of Guider. From now on, I would like to explain tracing features. Because of time limitation, I'm going to explain only function tracing, signal tracing, and IO tracing. The target of function tracing is divided into three kinds of thing. First, native calls such as C, Rust, and GoLanguage. Second, Python calls using interpreter. Last, system calls. Signal tracing is a signal delivered to the target. IO tracing is about IO operations at various levels such like device, task, and file. Tracing target is divided into program and task. Program is binary, not yet executed from storage. So Guider can execute their target program at which point the tracing begins from loaders. This is, yeah, task is a running thread. Guider does not require restart of the running task for tracing. Instead, it attach to the running target thread directly. Tracing commands are various. So if you want to see detailed commands and options, please refer to Guider help more. The first tracing feature is for native functions such as C, C++, Rust, and GoLanguage. Native function tracing is started by bit trace command. The command is implemented using backtrace called trap. Backtrace is for all similar addresses from ERF and DROP sections are injected to their target tasks virtual memory by Guider itself. So Guider can detect events for function call and function return from the target task by bit trace. Guider can even read and manipulate the registers and memory for the target task when function events occur. As shown in the picture, call states are shown with various steps for GoProgram in real time. Arguments and binary name for each function are also printed together in a line. The G option in the command line is task filter. That means all tasks have name including Go will be targets for function tracing. The H option means printing backtraces. If there was no H option in the command line, just all function calls are printed without depth. Function filter is also available with the C option to trace only specific functions. The C options are for specific characters such like asterisk for inclusion or some complex for exclusion. Using the H option, all backtraces are also printed when the target function is called. As I already mentioned, Guider can read and manipulate registers and memory for the target task at the time of each event. In addition, various features such like task control, injection for Python code and external binary, remote call are also available using call command. As shown in the picture on the right side, many call commands are supported to handle specific function call events. Let me explain some call commands, execute external command when function called filter, print context if only specific conditions are met, get erg, print specific argument value, set erg, manipulate specific argument value, get return, print return value and elapsed time when function return. PY file, execute specific Python script remotely, read mem, print specific memory value, write mem, manipulate specific memory value, sleep, wait for specific seconds, cscor, call specific cscor remotely, user call, call specific user level call remotely. This kind of call commands are values for when analyzing more deeply. This is about how to use call commands. Call commands are appended to the function filter with vertical bar in the C option. The command line at the picture means first, start tracing only a write function from yesavcd command. As you know, yes is just links command that print arguments value and finitory. So yes, abcd command will print abcd string repeatedly and print function is implemented internally by the write function in libc. Next, when the write function is called, print the memory value pointed to by the first argument with factories, argument number starts from jerof in guider, therefore function arguments for the write function is specific memory address that point to the value abcd to be written. I guess the yes program is implemented using preferred write because multiple abcd strings are written at once by the write cscor, like this. So previous function tracing features for the remaining functions, but how about programs written by jit compiler languages such like JavaScript? It's impossible to get symbol mapping information about them using just the only ELF tables or DWARF. But if the target test provides guider with jit compiled symbol address mapping information and jit compiled function calls follow process call companion, it's possible to trace them. Java and node.js can export symbol address mapping table using external file at runtime. Then guider can trace their jit compiled function calls after importing the mapping table. Yeah, like this. This is a tracing example about node.js. As shown in the picture, there are jit symbols in red boxes and native symbols outside. Function filtering for jit symbols is also a property. Next tracing feature is about Python function. Python function tracing is started by pytrace command. The command will print all Python method calls. As shown in the picture, Python call stacks are printed in real time at various depth depending on the step frame. File pass and line number for each function are also printed together. The target was IOTAP program that written in Python and prints IOCs in real time. Call commands used in previous native function tracing are also available in this picture. Next tracing feature is for Cisco. Cisco tracing is started by strace command similar to original links command. The command will print all these calls and their arguments converted into an easy to understand format. As shown in the picture, these calls are printed with that trace, return value, elapsed time in real time. Cisco commands used in previous native function tracing are also available for this feature. Next feature is for signal. Signal tracing is started by strace command. The command will print all received signals for the target task. In addition, the calls of the signal generation and the sender can be also printed when receiving segmentation fault child test, child signals. As shown in the picture, reserved signals are printed for target stress in real time and those stress were dominated because of segmentation fault caused by long memory access. Backtrace option and signal filter option are also available for this feature. Using backtrace, you can analyze which function is being executed when the target task received signals. This feature is useful when monitoring multiple threats to analyze abnormal termination between as segmentation fault. Last trace feature is in this term is for IO. IO tracing means analyze which task performed which operations on which files on which devices and at what size. And it's not only for specific tasks, but also all tasks, whole system. So it must be possible to collect all system IO events including various metal data such like task, device, I-node, or loading information. The IO tracing consists of three steps. First, recording all system IO events. And second, processing recorded data including conversion, last summarizing and reporting result. In the command line, IO like command is for recording system IO events into a specific file. Report command is for processing data reporting to a specific output file. As shown in the picture, first report information is about task work load in the red box on the right side of the picture. Black workloads are shown with elapsed time for read and write size and in megabyte. Operation count fills for each task. Not only workload, but also elapsed time is printed. It's very useful to analyze delay caused by IO system widely. The cache that IO is excluded in those tests because this is about actual block operation. So some operations using page caches are not measurable. Next report information on IO tracing is about device workload by size. In the red box on the picture, it shows the workload of each device through the reading operation of all tasks and the proportion about sequential operation. Most read operations consist of 4K workload in the blue box on the picture. About 57% of operations were sequential. In other hand, in other words, about 43% of operations were random IO. This information is useful when optimizing device workload including corner reader hand. Of course, not only total workload, but also per task workload is also shown at the bottom of the picture. Next report information in IO tracing is about file workload. In the red box on the picture, it shows the workload of each file for the write operation of all tasks. Most write operations about 100 megabyte performed into the test file. Actually, it's all about the guide thread using IO test command. This information is useful when tracing or analyzing task workload or file workload. Yeah, this is very nice. Next report information in IO tracing is about file operations. As shown in the picture, all read file operations are displayed including time, task, offset, size, and path. The total file size is also appended to the end of path in each line. In detail, the information, but analyzing is a little bit difficult. Yeah, so let me show demo finally. First of all, let's install guide using PIP and check version, check comments using hypercomment. Yeah, there are many comments supported with various OSs. If you use Hoption with any comment, options and examples for each comment will be shown. It's very specific data. So let's execute the yes program. It just print input string repetitively. Then, yeah, like this. And then executing background with redirection, like this. Okay, then let's monitor system resources with the top comment. Yeah. As you can see, yes process is using CPU merge and it is running on this core now. Yeah. There are many other steps as shown in real time. And next, let's profile system and tasks for 10 seconds with the top comment. Yeah. And next, open the output file, guide all that out. There is system information on the top of the file, like this. And system resource uses in each interval for 10 seconds and CPU usages for the whole system and specific processes, including yes is shown like this. In addition, virtual memory, digital memory, memory details are also shown. This is about detailed stats for each interval, like this, detailed statistics. Let's monitor this course with course text. Only write this course being used in yes program. Look at this. And this is the usual level course text calling the write this course. So, yeah. Next, let's monitor functions using CPU by sampling techniques with utap comment. It looks similar to previous Cisco course text, but it's about all usual level function course. Now, next one is about Cisco tracing with argument and course text. Yeah, this is write this course and its arguments and return value and elapsed time. And next, let's trace function with arguments and course text. Read the memory value pointed by first argument for the write function. Let's check. Yeah, like this. This is the address and the value is shown like this for a memory value pointed by first argument for the write function core. This is about core command. Yeah, next feature is visualization. This is a performance graph showing system resource uses about CPU memory, IO. This part shows CPU uses for whole system and processes. This is about total CPU and CPU uses for other processes. Yeah, this is levels for each graph. This part is about IO, but there is no graph because profiling options were not enough. And this part shows memory uses for whole system. Yeah, this is about eight. Next one is timestamp chart showing scheduling time slices for all tasks. Each number I shown on the left is the CPU core number and time slices running tasks in each core are also shown. If you move the mouse pointer over a specific time slice, information about task event and time is printed. Some time slices are here. Last one is frame graph for the cross text. If you click on a specific function box, zoom in is performed and mouse moving to specific slots, you can check detailed information. Yeah, searching is also supported with regular expression. So this is my talk. Thank you for your listening. And if you have any questions, please let me know it. This is the channel for communication with me. So don't hesitate to contact me. Thank you.


Welcome to our lecture series Math 4220 Abstract Algebra 1 for students at Southern Utah University. My name is Dr. Andrew Missildine, and I will be your instructor for this course. Before we jump into the content, let me just tell you a little bit of what to expect for this course. Math 4220 is the first of a year-long sequence in Abstract Algebra, the sequel being 4230 Abstract Algebra 2. Take a look for the links to that course if you want to if you want to view the videos for that as well. Abstract Algebra this year-long sequence is an undergraduate sequence for students at SUU where students will be exposed to the basic ideas of groups, rings, and fields with their accompanying proofs, theorems, exercises, examples, etc. What have you. This is an undergraduate course, so we'll take a much more elementary and slow approach to introducing these things as opposed to those in a graduate course, of course there. And so also mention that our lectures are going to be primarily based upon content from the open source textbook Abstract Algebra Theory and Applications by Tom Judson, for which you can find a link to his textbook in the description of all of the videos in this series. Now Judson's textbook will take the same approach that we do that our coverage of Abstract Algebra will be a group's first approach, meaning that we're going to start with the most fundamental Abstract Algebra objects and add axioms on top of that over time, which means primarily we'll be talking about groups this semester and we'll end the semester with the introduction to rings and fields. And then in the second semester, 4230, we would continue our development of rings and fields, other related objects, like vector spaces, we'll say a little bit more about groups as well. And that's the basic structure of this course. Now starting with the most fundamental of all objects here, section 1.2 of our textbook entitled Sets and Equivalent Relationships. With this section, we're going to start off with the idea of ace. Now in Judson's book chapter one, entitled Preliminaries, is supposed to get us warmed up to many of the objects that we have to be aware of in the Abstract Algebra setting. Section 1.1, entitled, what was it? It's a review of some ideas of logic and proofs. It's very, very short. And we will talk about all those ideas spread out through section 1.2. We'll actually spend a couple lectures, the first three or four lectures, I believe, in section 1.2, as we review a lot of these fundamental ideas, because this will be important review for students of Abstract Algebra. So the most fundamental of all structures, really from a mathematics point of view, is going to be the idea of a set. Now, formally speaking, our notion of a set will be that notion derived from the ZFC set theory axioms. If that doesn't mean anything to you, that's perfectly fine. We aren't going to dive into that deep, deep, deep set theory whatsoever. Admittedly, in the next semester, we'll talk a little bit about the axiom choice in its context, mostly to Zorn's lemma. But for class, really, all we need to know about a set is that a set is a well-defined collection of distinct objects. Those distinct objects, we typically call the elements. And this is a chemistry analogy that the elements are the things that make up the set. And they really are the minimal objects. You don't really break down the elements of a set anymore. They belong to the set, and that's what it is. What do we mean by well-defined? This is actually what got set theorists into problems a long time ago. Things like Russell's Paradox come into play if we're not very careful about what it means to be well-defined. So the classic example about Russell's Paradox, as a professor explained it to me once upon a time when I was an undergraduate student, was the following. If you have a crazy man who runs into a barber shop and he decides to shave off everyone's hair who's not shaving themselves, you can imagine it's most people inside the barber shop. But what about himself? If he's in the barber shop, if he shaves off his own hair, then he shouldn't be cutting off his own hair, so okay.  There's a logical paradox with our crazy barber there. And so it's not well-defined whether he should slice off his own hair or not. And so it turns out that in early very naive set theory, sets were often defined in this ambiguous way and therefore to be a well-defined object meaning that there is a clear rule that enables one to determine whether a given object is an element of the set or not, like with our crazy barber who wasn't well-defined whether he should cut off his own hair or not. And there has to be a clear rule, right? Definite rule. Absolutely it is or absolutely it's not. Now that rule doesn't have to be an easy rule, right? It could be like a three-hour computation to decide whether you belong to the set or not. It could be a year-long computation. There's many open mathematical problems where it's not certain whether an object belongs to a well-defined set or not, right? People are still actively looking on it. But the fact that the rule of containment is easy or hard is beside the point. To be well-defined means there is a rule that we can decide if there are not. Now one important set that we're going to see a lot this semester that I'll introduce now and we're going to see it a little bit later is the idea of the empty set. The empty set is the set that has no elements. So no elements belong to the empty set. And so we define this typically using it's like a circle with a slash through it. I usually draw it like this. The latex symbol here looks more like a zero in some fonts, but the empty set would be a circle with a line through it. Sometimes it's denoted by two curly braces with nothing between them. That notation will make a little bit more sense in a moment. That gives us our empty set. Now talk about general sets because the set itself is this collection of things. It's a family of elements. We talk about the set by describing who belongs to the set. So a set's usually depicted either by listing all of the elements inside of a pair of curly braces, kind of like you see right here, a little bit of notation. We typically will denote sets by capital alphabetic letters. We might say things like A, B, C, X, Y, Z, just as examples of sets, typically capital letters. And the elements of the set are going to be typically denoted lowercase letters. And if there's no confusion, we might try to use mnemonic devices like little x belongs to capital X. That one can be a little bit more confusing because little x and capital X look very similar in font style, but we might say something like little a belongs to A. And this is usually meant as a mnemonic device to help us keep track of which element belongs to which set when we're talking about multiple sets simultaneously. One way of describing a set is simply just to list all the elements that belong to the set. So for example, set A equals the numbers one, two, and three, something like that. And be aware that the elements that belong to a set can be anything. They could be numbers. They could be people. They could be Pokemon from the Galore region or whatever, whatever we're trying to talk in the in the current context, right? When it comes to listing all the elements of a set, this works out really well when you have a finite set because it might just be a finite list of numbers. But even if the set's infinite or it's just a very large finite set, it can be difficult to list all of the elements of a set. So one might say something like the elements of my set are going to be dot, dot, dot, comma, negative one, zero, one, two, three, dot, dot, dot. Sometimes we use things like ellipses to indicate that there's some pattern associated to the elements of this here, describing the set of integers. We want all integers. And so I listed a few so you can kind of predict the pattern. Dot dot aka ellipses approaches isn't the most well-defined way of describing a set. Because whenever someone uses dot, dot, dot, there's an inherent pattern that the author is referring to. But that pattern could very well be ambiguous. For example, if we describe a set in the following way, c equals one, two, dot, dot, dot. Well, what's the next element of the set? You might be like, oh, it's three, four, five, six, it's doing the, you know, it's just doing the usual counting sequence of positive, like one, two, three, you might think is the next number. But why not like one, two, four, maybe eight? Like it could be a geometric sequence for all we know. Or it could be like one, two, six, it could be the sequence of factorials. The next number is three factorial. The next one's four factorial. Or it could be like one, two, three, five, eight. Maybe it's the Fibonacci sequence. We just forgot the first number one or something. You know, if you don't get enough information, the sequence in play can be very ambiguous. So we try to avoid that when it's possible. But again, context, we often play on that into concepts. A much better way to describe a set is in the following idea that we describe the set using some type of criterion, some type of criteria rule. So imagine that P is a statement of some kind. And so we might say that X belongs to the set if X satisfies some statement, some property associated to that element. And we'll see some examples of that in a little bit. This is often referred to, you see the green circle there, set builder notation. We describe the elements of a set according to some property. And this is going to be the way we describe sets probably most commonly in this mathematical setting to avoid some of the ambiguities that can happen when a set is too large to list all the elements in there. Now the set is really determined by the elements that belong to the set. And so because elements in a set are themselves distinct, we do not, we don't let repetition occur inside of our sets. So when you look at sets like this, one, three, two, one, three, two, we make no distinction between these sets. Now when I say we don't allow repetition, that doesn't mean elements can't be repeated. What that means is when elements are repeated, we make no distinction there. It'd be like saying like my favorite pizzas, let's see, I love pepperoni pizza. I love Hawaiian pizza. I love pepperoni pizza. I love cowboy pizza. I love pepperoni pizza. I love meatlover pizza. Oh, and I love pepperoni pizza. The fact that I listed pepperoni four or three times how many was doesn't change the fact that I like belongs to the set of pizza flavors, pizza toppings I like. So we distinguish between repetitions. Now in this situation where we list the elements one, three, two, two and one, three, two, it might seem silly, why do you list two twice? But it could turn out because of the set builder notation, the property, the rule and play, might actually very naturally produce the same element multiple times. And it just might not be clear from the beginning. If it does produce the element multiple times, we don't distinguish those. Also, the order, so, so in this regard, these two sets are considered the same set even though one of the elements is repeated more than once. The order in which elements are arranged also is irrelevant. That is the set one, two, three, one, three, two and three, two, one are all considered the same set. When it comes to being a set, the only thing that matters is set containment, not how many times we repeat the element or the order in which they're described. And so for the idea of a set, we don't care about those things like order and repetition. If we did care about order, sorry about, if we cared about repetition, we could talk about something called a multi-set, which is something very important and common in torques that we won't worry too much about. If we did care about ordering, we'd have some type of array or be like an intuple of elements, like the splits of elements that we care about order, but we don't, not when it comes to a set. When it comes to a set, the only thing we care about is containment. We have a symbol that describes this relationship when considering if an object is an element of a set or not, we use this symbol right here, kind of looks like an E. Honestly, I think it's, I think the symbol sort of derived from the symbol Epsilon, the Greek letter Epsilon, although it doesn't really look like an Epsilon anymore. The symbol Epsilon, all right, in this case the symbol here that looks like an Epsilon, this means that you're an element of a set. And then if you put a slash that symbol, that would negate the symbol. That's true for basically any mathematical relationship, draw a slash through it and negates that object. That would mean you're not an element of the set. So consider the following example, take a very simple set A equals the number, the set of numbers one, two, three and four. The number two belongs to that set. So we would write two is in A. That's all there is to it. On the other hand, the number five is not inside of that set. So we would write five is not a member of A. That's how we, that's how we use the symbol there. Very simple, basic. There are some important sets that you should know by definition. These are going to have some important, these are important sets. So we're going to attach some symbols to them. If you see this symbol right here, this, when you write it by hand, you'll often just write an N with an extra line on it. This is our blackboard N. That's the official font and latex for this thing. And this is even the set of all natural numbers. So N is a natural number in this context. And by natural numbers, we need the non-negative integers, zero, one, two, three and et cetera, going on and on and on. Now, I should mention that the way we are defining the natural numbers is we will include the number zero. Many mathematicians, when they define the natural numbers, they don't use the number zero. And there are many reasons for doing that. For example, Judson's textbook for which this, which our course is based upon, actually defines the natural numbers as the positive integers one, two, three, four. It excludes zero. And I think, I disagree with that statement. I mean, there are good reasons to exclude zero. But in terms of the, fundamentally, do they do, the natural numbers are counting numbers. They count things. For example, they count the sizes of finite sets. If ever you see a set A and you put what looks like absolute value symbols, this is going to count the cardinality of the set, which this means the number of elements, the number of elements in the set A. And this cardinal number, if A is a finite set, will always be a natural number. So if you take the example we had from before, like, say this is our definition of A, then in that case, the cardinality would equal four. On the other hand, if we take the empty set, well, the, the size, the cardinality of the empty set would be zero. There's no elements inside of that. And so since zero is a num, a natural cardinality of a set of a finite set, we do allow zero inside the set of natural numbers. But like I said, there are many mathematicians who have strong reasons why they shouldn't. And why can't the mathematicians decide? Well, because there's good reasons in both camps there. And so it's kind of interesting to have the two competing thoughts there and having, having you kind of decide for yourself the right approach there. But for our, for our lecture series, zero will be considered a natural number. And also some algebraic benefits that the set of natural numbers actually becomes a monoid because it has an additive identity. Things we'll define in the future. The set of integers we will denote using blackboard Z. This actually comes from the German word for number, which in the German alphabet starts with a Z. The integers are going to be positive, negative or zero, right? So we have positive integers, we have zero, we have negative integers. I won't say too much about that. We have the set of rational numbers, which we're going to denote using blackboard Q. Q here stands for quotient, because a rational number is going to be a quotient of integers. So we look for fractions of the form P divided by Q, where both P and Q are integers. See the notation there. But we also require that Q cannot equal zero. And the rational numbers will have the usual equivalence. Notice that there are different, there are different integers that produce the same fraction. For example, one half and two fourths are the same rational number. So the rules that determine the set of rational numbers can produce multiple representations of the same element, things like this. This is what we were talking about beforehand. These are considered the same rational number. The blackboard R will represent the set of real numbers. And blackboard C will represent the set of complex numbers with the usual interpretation. A complex number Z has the form A plus B I, where A and B are both real numbers. A is the real part, and B is the imaginary part. So this gives us a very basic introduction to sets that will be useful as we study abstract algebra in this course.


What's up everybody welcome back to the channel? It's that time of the day to give away another autograph poster card That is the Achilles radials poster card of Robbie Nishita. We got our generator up We got our names ready to be picked and the winner of the autographed Robbie Nishita poster card will go to Robbie's to rotten with a comment. I want that poster Robbie's to rotten welcome to the channel I know you are a new subscriber to the channel. You did add me on Xbox so looking to get some slides with you some time So congratulations for winning that autograph Robbie Nishita poster So make sure you guys are commenting on the videos every single day if you guys want chance to win the Autograph poster card so until tomorrow. I'll see you guys later


Europe, moles delivering F-16 fighter jets to Kiev. Ukrainian Foreign Minister Dmitry Kuleba said that unnamed European colleagues were working on the issue of delivering US-made F-16 fighter jets to Ukraine. In his account on Facebook, the Ukrainian top diplomat published that he claimed was a conversation with an unnamed European colleague. According to the publication, the official tells Kuleba that he was beginning to work on providing Ukraine with F-16 fighter jets. He knows what to do. Kuleba wrote about his interlocutor. On January 20, another meeting of defence ministers from approximately 50 countries was held at Germany's USAF Ramstein airbase, where further aid to Kiev was discussed. Ukrainian President Vladimir Zelensky, addressing the meeting via video link, asked the western top military officials to speed up the deliveries of tanks, artillery and air defence systems to Kiev. Additionally, he hoped to obtain F-16 fighter jets and long-range missiles at future meetings. The issue of deliveries was earlier raised during debates in the parliament of the Netherlands. Later, the country's Prime Minister Mark Root said that this issue was out of question at the moment, but added that nothing is ruled out. Modern western fighter jets have also long been one of the most in-demand items, as far as Ukraine is concerned. But so far, no concrete commitments have been made. Assistance in terms of fighter aircraft has been limited to air-launched weapons as well, as well as spare parts for existing aircraft. In the case of the F-16, you have a lot of options for different training programmes, different electronic countermeasures, different engines, different everything. It's like Lego, the Ukrainian MiG-29 pilot known only by his call sign, Juice, told the war zone last December. In general, I don't say that the F-16 is better as an aircraft itself, but it may be the most realistic choice for Ukraine, considering capability, availability, affordability, and most importantly, sustainability.


Hello everyone, I am Anjali Singhal, my master thesis project is on energy efficient applications for low power devices. Now energy efficiency can be discussed at three stages, that is first at the architecture level, at the system level and at the application level. At the architecture level, the processor usage can be reduced by using multicore processors. At the system level, we can do hard disk spin down and compiler driven optimizations to achieve energy efficiency. Similarly, at the application level, we have lot of user information, which the developer can use and he can change the algorithm and the source code or the design, so that energy efficiency can be achieved. But for this, the developer must have insight about where the energy is actually spent. So, in that case, we will be studying some optimizations in this talk. In the basic form, the basic functionality which we used to have is calling, messaging, etcetera. Nowadays, phones are not only just used for the basic functionality, but also for the multimedia and mailing, etcetera, many other applications have come. So, adding the basic functionality and the main applications, so adding the basic functionality and the main applications we have that is present in the current smartphones and the new phones. So, hence there are more applications, so the power consumption will be very high because each application is consuming very significant amount of power. Now, many developers across the whole world are creating Android applications and are uploading the applications on Android market, so that many users can use them, but they generally care about the functionality of the applications and not more on the power consumption. Hence, what happens is the battery of the phones drain very quickly and the end users have to suffer. So, if the developer give as much importance to the functionality, to the power consumption as much to the functionality, then the impact will be very high for improving the energy consumption. Now, if we see the division of power consumption among the different components, then the major consumers of power are GSM module, CPU and display. In display that includes LCD panel, touch screen, graphics driver and the backlight. So, if we can turn on, if those components are not being used, then we can just turn off the components, so that the energy consumption will be reduced. So, the most effective power management approach is to shut down the unused power, unused components. And also it has been found that the free apps which we download have the free advertisement modules and they consume 65 to 75 percent of the total energy, because there is lot of IO energy which is being wasted in the advertisement modules. Hence, in this talk we will be seeing many optimizations which can be done at the application level, so that each developer can contribute to saving the energy for the end user's purpose. First we will key energy bugs, then optimizations which includes many network intensive applications etcetera and then some other optimization and conclusion, so energy bug. Okay, so in Android every component remains in the sleep state until it is waken up explicitly. So, that is in power management in Android, when we want to use any component in our application, then we need to define a wake log instance, so when we need to use any component, then we need to define wake log for using that component and we have to define wake log as one of the four, one of the options which we will be discussing further. Wake log is an instance of power manager dot wake log class and while initializing it, we have to pass a parameter, that will be one of the options which we will be discussing, that will switch on or off the component, switching on and off means that that component will either be in the high power state or the low power state, when we switch on the component then that device or the component will go in the high power state and similarly when we switch off the component, then it will go in the low power state. So, in this diagram we can see many options which we can pass as a parameter while initializing the wake log instance, like if we pass partial wake log, that means only CPU will remain on, so while initializing the wake log we can pass any of these options, suppose we pass partial wake log, that means the CPU will remain on, like if in our smartphone if we do not use it for some time there is a period of inactivity, then it will go in the sleep state. So, if we define this partial wake log, then it will remain in the CPU will remain on irrespective of the inactive state, similarly in the screen dim wake log the CPU will remain on as well as the screen will remain dim and similarly screen bright wake log and in full wake log the CPU will remain on and the screen will be bright and keyboard backlight will be on. So, now we will see how we can use this wake log to actually switch on any component. Before that when we how to use this wake log, now when we define a wake log is an instance to switch on of any component, initially if the component is in low power state and then we acquire the wake log, then the component will go from low power state to high power state. Similarly, when we release the wake log, it will go from high power state to low power state. Now, in this example we defined an instance of power manager dot wake log class and initialized it with the option partial wake log, that means the CPU will remain on irrespective of the inactivity state. So, now when we do write WL dot acquire, that means that CPU will should not go to sleep and now we can write our code and it will execute and after finishing our application we should release the wake log. So, that we can say that now CPU is free to sleep if it is inactive. Now, energy bug what is energy bug? It is defined as an error in the system. The system will behave very normally. The application will work as per the functionality operating system will work as per the functionality, only that there will be a huge energy drain unexpected amount of energy drain, because the end user cannot figure out why so much energy is being drained, but the functionality will be normal. Now, we have it is categorized in two parts, no sleep bug and the looping bug. In the no sleep bug suppose you acquired a wake log in your some part of the code and you released you forgot to release, then there will be a no sleep bug or if you have even released the wake log in the code, but due to some unexpected event or exception that code did not execute that will create no sleep bug. Now looping bug in looping bug suppose your application is trying to connect to an outside server and that server has crashed. Now, your application will keep on trying to contact the external server and the network device which is trying to connect will be remain on and hence the energy is wasted. Now, we will see as we have seen in the previous talks that android applications have activity, broadcast, receivers, services etc. So, we will see what is the expected way to write an activity and using wake logs. Now, we know that activity started on on create event and it is destroyed in on destroy callback. When the activity is paused it is in it is not in the foreground, but visible. So, in that time when it is paused it will call the on pause callback. If the developer has released the wake log in on destroy, but not in on pause that will create a no sleep bug because the application is not running it is paused, but still the device the component is in high power state. So, wake log should be released in on pause callback also and then again it should be acquired in on release on resume callback. Similarly, in service there is a on start command if the service is bind service then on unbind and on handle intent callbacks at the end of these callbacks the desired task should be completed and the wake log should be released. And in the broadcast receiver also on receive callback should at the end of it it should complete the desired task as well as it should release the wake log. Now, for analyzing all these whether the application has no sleep bug or not we can do static data flow analysis. So, that the no sleep code paths can be find out. Now, we will see an example through the code that how this analysis can be done. Suppose, we have this code we are acquiring CPU wake log here we are acquiring GPS wake log here we are releasing the GPS wake log here and we are releasing the CPU wake log here. Now, each use of the wake log is defined as in definition we are doing the reaching definition analysis here reaching definition data flow analysis. So, each use of the wake log is a definition like in this block B 1 CPU acquire is a definition which I have defined as D 1 and I have denoted CPU wake log as C W when I am acquiring it I am assigning 1. So, C W equal to 1. Similarly, GPS wake log I have defined as GPS it is the definition 2 and because I am acquiring it I am assigning it 1. Similarly, in block 2 I am releasing the wake log. So, I am assigning 0 and it is the third definition and similarly in block 3 I am assigning 0 because I am releasing the wake log for CPU. Now, for each of the block I will calculate generate and kill. So, which definitions are generated and which definitions are being killed because of the other definitions. Now, if we see B 1 block they are 2 paths from 2 paths through B 1 1 is through B 3 and 1 is through enter. So, enter does not have any information coming outgoing which will be received by B 1, but B 3 is passing on the information to B 1 that is now I am defining here D 1 and D 2. So, it is generating the definitions D 1 and D 2 whereas, the previous definition which I have assigned for C W is C W equal to 0 that is D 4. Now, I am again assigned C W equal to 1. So, that D 4 definition will be killed by D 1.  Similarly, GPS equal to 0 is there in D 3 which will be passed on to B 1 through B 3. So, that will be also killed by D 2.  Similarly, for B 2 I will calculate gen and kill I have defined definition D 3. So, D 3 is in the gen set and in the kill since I am assigning GPS equal to 0, B 1 is passing on the information D 2. So, D 2 definition will be killed because I have assigned 0 now. Similarly, in B 3, I have the new definition which is generated is D 4 and the definition which is killed is from D 1 because of the definition coming from B 1 to B 2 to B 3, D 1 will be killed. Now, we will calculate the in and out. It is the process to calculate to do the data flow analysis for reaching definition. The purpose is at the end exit block, this end block I will find that which of the definitions are reaching ultimately here. So, that I can know that if any acquire definition is reaching here that means there is a no sleep bug. So, I will do the reaching data flow analysis. I will calculate out and in for each block and ultimately you can see that in the exit block I have D 2, D 3, D 4. That means D 2, D 3 and D 4 GPS 1, GPS 0 and C W equal to 0. These three definitions are reaching at the end of the out of the exit block. That means there is some path through which D 2 is reaching, D 3 is reaching and D 4 is reaching. So, GPS equal to 1 acquire is also reaching through some path which means there is a no sleep bug and as we can analyze from the path itself if the code takes this path enter to B 1 to B 3 to end, then the GPS still remains 1. It is not being assigned 0. So, we can calculate through all paths that there is a no sleep bug. Now, the other optimizations which we can do first of them is application optimization at the design level. Now, when you are designing any application then depending on the need suppose your application is IO intensive that is a video streaming application. So, you will need to read and write a lot that means if you compress your code or you compress your data and you read and write then the date it will be more efficient. Whereas, if your application is CPU intensive then you should use uncompressed code because the CPU usage will be less. Similarly, the applications needing continuous, but variable workload the scaling the frequency according to the workload will be most beneficial. So, if the developer has all these information at the design time then he can use it to optimize the application for energy efficiency of the application. Next optimization is the battery virtualization. Now, if I am going somewhere and I am playing games etcetera then my most of the energy is wasted in playing games, but I need my mobile to have sufficient energy for receiving calls or messaging. So, I can so what they can be done is they we can have in battery allocation for each application class that is navigation, phone, games etcetera. Each application will be assigned certain fraction of battery as per the users policy. So, that they will not be after certain fraction they will not be allowed to use these applications. If the battery runs very low then they will not be allowed to play games etcetera like that. So, these can be enforced as a policy which my friend earlier mentioned that implementing the policy framework and we can create an android service which will periodically check if the fraction of the energy assigned to that application class is what is the amount of energy that fraction of energy which is left for that application class and accordingly taking the action in that service. Now, the next application optimization is in network applications. Now, if I am trying to send any data transfer then first of all my network device will go in the high power state. So, the whole energy consumption during the data transfer is divided into three parts. First is the ramp energy, then transfer energy, then tail energy. When the device go in the high power energy from low power state to high power state then that amount of energy is called the ramp energy. When the actual data transfer happens then it is called the transfer energy and the rest of the time the device is in high power state is called the tail energy. Now, as we discussed earlier network devices are the major consumers of the total energy consumed by the application. Now, if our application is using 3G, Wi-Fi or GSM then in 3G the tail energy is very significant amount as compared to the transfer energy whereas, ramp energy is very small. Similarly, in GSM the tail energy is comparable to transfer energy, but it is less compared to the 3G and in the Wi-Fi the scanning and association energy is very high and maintenance energy also to maintain the link. So, as we can see the is the tail energy consuming significant amount of energy, but it is not doing any actual work during that energy. So, how we can utilize this tail time? In three ways we can utilize it that is the tail aggregation, tail tuning and tail theft, tail aggregation. So, what we do in tail aggregation is we differ any request transfer request that is coming to its deadline. So, that the two or three transmissions will overlap and the tail time will be overlapped that is in the tail time of one transmission I will send the data of another transmission. Hence the tail time will be actually used for transfer and the inter transfer time will be decreases. Similarly, in the tail tuning I will reduce the tail time. Now, reducing the tail time will increase my state state promotions because if I reduce my tail time and in the near future I have a transmission again then again I have to switch on I have to transfer my network component into high power state. So, again and again there will be state promotions from high power state to low power state to high power state like that. So, it will instead create increase the power consumption. Hence if we are doing tail tuning then very high prediction accuracy is required. Now, tail theft in the in the tail time a virtual tail time is maintained along with the physical one. So, that now we can schedule the smaller transmission during the virtual tail time, but the drawback is that if the tail time ends before the transmission then the transmission is cancelled. So, for that we can either divide the chunk make chunks of the big transmissions into small ones and then we can send the small transmissions in the tail time virtual tail time. Now the other optimizations which can be done. So, as we discussed network devices and display and CPU are the major consumers of power consumption. So, in the display the backlight consumes highest power then the LCD panel and the frame buffer. So, if for the backlight if we change the ambience according to the ambience if very brightest bright ambience is there then we can reduce the brightness of the backlight. So, that the energy consumption will be less. Similarly, for the frame buffer etcetera we can it is the frame buffer is being refreshed at very high rate. So, if we can again again we are writing into the frame buffer etcetera. So, if we can encode the frame buffer then the size which will be again and again written will be very less. So, that encoding will compress the frame buffer and it will reduce the energy consumption. So, in the conclusion we studied energy bugs which we studied detection of energy bugs and possible causes which will which will create the energy bugs etcetera and also we studied different optimizations in the network intensive applications display for display we studied how we can reduce the power consumption etcetera and how we can utilize the tail time. So, that we can actually transfer use it and transfer more data during that time.


This paper proposes a novel approach to detect and classify brain tumors using deep learning techniques. It uses a combination of convolutional neural networks, CNNs, and residual networks, ResNets, which are both well-known methods in computer vision. The CNNs are used to detect the presence of tumors in the image, while the ResNets are used to classify the tumor into benign or malignant. Additionally, the UNET model is used to segment the tumor region more precisely. The model was tested on a publicly available dataset consisting of 120 patients, and it achieved high accuracy rates of up to 95%. This article was authored by Abdullah Asairi, Ahmad Shaf, Tariq Ali, and others.