All right, let's get started. So today, we're going to build on some of the things we looked at last time, processes and threads, and look at some of the more details of how those are implemented and what their implications are. All right, so we'll review some of that material from last time, so it all looks familiar. We'll look at how threads get dispatched and how they can cooperate with each other and give some examples of concurrency. And we'll also sort of clear up some of the terminology that was left. We didn't quite get to last time. So multi-programming is the fundamental idea that's associated with processes. It's the idea of running multiple application programs at the same time on a processor. It's actually an old idea, so it predates interactive time sharing systems. It was originally used in mainframes that did batch processing. And basically, it would pull several jobs into memory and switch between them simply to utilize the CPU. So it would avoid the CPU being idle when one of the jobs is waiting for an IO operation. So it doesn't imply the real-time process systems that we have today. But on the other hand, there aren't many multi-programming systems that aren't interactive anymore, because there aren't really computers of that type. So multi-programmers become a bit of a synonym for multitasking, which means running those jobs with faster updates such that not only are there multiple virtual machines resident on one machine, but the perception of a user of any of those virtual machines is that they're actually running. They're not suspended for some amount of time. All right, so multi-programming is just simply that model that there are multiple resident processes in the one system's memory. And there's some regimen for switching between them and finishing all of them. It typically involves encapsulation of each process as a virtual machine with its own copy of memory, some kind of protected handle on the IO devices so that there isn't conflict between the different multi- different programs running on those different virtual machines. So the process is this abstraction that captures the program plus its running state and is typically associated with a virtual machine perspective. So the process is the thing running on the virtual machine, but the virtual machine is the thing that provides protection and an environment that simplifies the programmer's task of writing the code of the process, because from their perspective, they're just coding effectively on one machine. So process creation certainly is expensive. Switching between single-threaded processes is a little bit expensive, although we'll talk about that more. It's a lot less expensive than it used to be. Primarily, we want concurrency between complex applications. And so that's why we use threads. Within a process that's large and complex, we typically want to be doing many things at the same time, perhaps dealing with a network, dealing with the user interface, and so on. And those different threads of execution can most easily perform efficiently if they have shared memory. And so therefore, threads are a way to handle that. So with the thread, we separate the execution part of the process, the runnable state of the process from the allocation of the virtual machine. OK, so here's a Unix process. So it'll have the code over on the left, a memory. It's the virtual machine, so it has memory, including a stack and a heap, some IO state, and then the state of the CPU. So this part here are the resources that are being replicated as part of this process for each process, sort of the virtual machine part. OK, the instruction stream is a conventional sequence of instructions. And these resources here are managed some way, like memory we saw last time was actually partitioned. The physical memory is partitioned between the processes, so each one has its own apparent memory copy. IO state is similarly there are handles presented to each virtual machine so that the processes feel like they have access to everything. The CPU state, there's only one CPU though, so the operating system becomes responsible for basically making and maintaining copies of that that get swapped into the physical machine as you switch between processes. So that's the stuff that needs to get managed in order to do context switches between threads or processes. OK. So when you switch between different processes, the switching overhead certainly used to be quite high. We're going to look at that in some more detail now, because it's actually a much more complicated question, what you mean by a context switch for a process when it's multi-threaded. But anyway, it's more work than simply a thread switch. There's a small amount of CPU state to manage. A lot of memory state to manage that state has to be created and initialized when you start the process. And for that reason, the creation of a process is a lot of time. In fact, it's an arbitrary large amount of time, because it can involve initializing a large block of memory and also the typically a mapping table between the processes, view of memory and the physical memory. But it does provide very high protection of the CPU and high protection of other resources. Yeah, and we also saw last time that it's kind of expensive to do shared memory. You have to somehow allocate blocks from different processes that are the same physical block. And then also you have to do a context switch between them. So something written by one process can be read by another. Yeah, it's all the instructions that are run in between running the code of one process and the code of the other. So it's operating systems, calls, physical machine interrupts, often some very expensive instructions that are saving lots of registers somewhere. There's quite a lot of hardware support now for context switching. So all of that is happening in between when one thread stops or one process stops and another one starts. So that's the overhead part. So let's see. Oh, OK, all right. Yeah, and on a single CPU architecture, we're only running one process at a time. All right, now in contrast, threads, because they don't involve switching of memory or IO resources, have a somewhat lower switching overhead. They also have a lower creation overhead because a thread is going to be running in a particular memory environment of a containing process. So there's no need to initialize that memory. All that needs to happen is that the registers need to be initialized for that thread and a stack. One or two stacks need to be created. That's a very small amount of overhead. The threads protect the CPU state whenever you do a context switch of a thread. The old state gets saved and some new state gets read into the CPU. But the memory management's entirely up to the programmer. All the threads will have access to the same memory. Yeah, and the cost of sharing is low, meaning you can easily share data quickly between the threads because the context switching is fast. All right, and when you run this on multi-core processors, you even reduce somewhat the overhead of switching because there are actually registers that set trial on each of the cores, which can potentially be running distinct threads. And so you avoid that overhead of storing and saving registers as long as you're staying within one thread on each core. Yeah, so for four threads without context switches, there's no overhead. Typically, you want to switch some of those threads with other threads, and the usual overhead will come in. But if you think about it, the switching overheads only happening about one quarter as often. All right, and lastly, hyperthreading is a kind of a special support for threading where within each core, which by definition contains one copy of most of the CPU resources like arithmetic logic unit, memory management, and so on, they do have, though, multiple copies of the core CPU state, namely the registers. Because a hyperthreaded core has multiple register sets, there's no need to switch the state between them. No need to save them and read them back in. So the context switch is often like a single instruction of the order of nanoseconds, which is much faster than conventional context switches. The downside, though, is that when you switch to your other set of registers, you may not be able to do anything if you may be waiting for any of the other operations in the core to finish. So hyperthreading give you somewhere between a factor one and two improvement most of the time. All right, and last time we introduced the process control block. All right, so that's the current state of a process, including things like the state that the process is in, whether it's ready, running, et cetera. Number, to identify it. It's program counter, the register state, memory limits, and perhaps a map location, and then a list of the IR resources. Yeah, question? Yeah, so there's two different, yeah. So this is for a classical process with one thread. There's typically a different structure called a PEB. I'm trying to remember the acronym for that, but that's a process environment block, I think, is the name of that thing. And that's typically used for multi-threaded processes, and it doesn't have the, you instead have separate thread control blocks for the threads. OK, so we looked at last time at this switch from process to process. So these process control blocks are bits of memory that save the running state of a process. When you want to switch, you have to read that running state into the CPU. So let's say we're executing a process P0. When there's an interrupt or when it yields, then those objects on the previous slide get saved into a memory location in the form of that PCB struct. And when you're done there, the OS can reload the state of some other ready process, put it back into the registers and so on of the CPU, and then basically transfer control to the PC address in that PCB, that causes the second process to start executing. And that will iterate, run for a while until something makes it stop. It'll come back and save its state and so on. All right, so that's canonically what the context switch is. And as we mentioned, part in the middle, that code is typically running in the operating system. So along with these, the horizontal arrows is often a change in running mode from user mode to kernel mode and back again associated with this. And that means that the code in the middle can typically access many more critical resources than the user code, but when the user code runs, it has access to its own resources. OK, so last time someone asked about the actual practical times for doing this. So I went around and read some papers. And it's actually quite interesting. So for a context switch in Linux, current Linux, it's around three to four microseconds to do that on also current Intel CPUs. But there are some surprising numbers around this. So actually, right now, there isn't much of a difference between context switching for a single threaded process versus a single thread. So it's definitely doing more work. But for a variety of reasons, that extra work, saving some process of state to do with the IO resources and so on, into memory is very fast. Anyone want to guess why that would be? Yeah, it does have some specialized hardware for context switching, and that helps. Although, funnily enough, it seems like a lot of the common operating systems aren't using the hardware instructions for context switching because they're a little bit too aggressive in saving the register state. So the operating system, the software, typically knows what exactly stuff it needs to save. And so Linux and Windows actually do that in software still. But there's another piece of hardware that can help saving a loading. Yeah, so that's the key thing. Although you've got to save this extra bit of state, it's not very big. It's sort of tens of words. Even if it's a memory map, I guess you don't save the whole map. That's just a piece of memory. The point is it's not very much. And it fits easily in the inner cache. And when you have threads running back and forth, even dozens of them, you're really not consuming much memory. So that state that's flipping back and forth and sitting in the inner cache and is accessible very, very fast. So in fact, the caching has really accelerated the context switching to the point where it's hardly different between processes and threads. Assuming, again, that the process is a single thread. OK, but there are some big differences in performance, depending on other factors. So the context switching in a multi-core system, there's no particular reason that a particular process or thread will run on the same core the next time. It's normally going to run on an available core, which will often be different. So that has a bad cache consequence. Why is that bad from a caching point of view? Yeah? Yeah, so the Intel machines have level one and level two in each core. Sony out level three is shared. So yeah, so there's really fast cores. They'll only have the state of that process if you run it before. And if you run it a long time before, it'll be stale.  Another thing is that there's a sort of related memory penalty which is related to working set. So that's the part of the memory that the processor has been using recently. So this is not automatically managed. But when a process runs, it has something called a working set, which is a set of memory locations that it's just regularly hitting over an interval of time. When you stop the process, it's sort of ranging over this set of memory locations. When you start, it's going to range over the same set. In the meantime, other processors might have been ranging somewhere else and kind of pushed that working set out of the cache. So when you start your process again and it wants to start using that memory again, that memory has to get swapped back in. So if those working sets are large and even in the tens of kilobytes, suddenly the context switching becomes, and this is like the net overhead. This doesn't happen instantly. It happens after your process runs for a little while and starts moving over its working set. Well, the process has all the stuff that's related to an entirely different memory, a virtual memory copy. The thing is that that state that's associated with a different memory copy is also in memory. So you're not moving it around. So basically, different processes, I really want to show that picture from last time, but if you recall, there was a picture I showed with physical memory divided into blocks. Some of the blocks are associated with a process, process one. Some of the blocks are associated with process two. So processes are just dealing with different memory. There is some state needed, a small amount of state to sort of tell the process to use, say the blank locations versus the white locations. So that threads don't have that. All the threads running in this right hand process are, you know, they have exactly the same view of memory. So there is additional stuff associated with the process, but it just turns out that actually moving it around and changing it is very fast, yeah? Well, no, I mean, no, the process. So I, well, you know, you can think of it as a process which between these two processes as being a threads, a thread context which with a little bit extra, right? The extra is just changing around the memory map roughly and the IO map. So yeah, that's valid. But again, they know that the process, the idea of a process and a thread is still distinct because one has this extra stuff that makes the virtual machine appear the way it does. Correct, yeah, yeah, if you have a big process with lots of threads, switching between those threads is gonna take about the same amount of time as switching between two very simple processes that have a single thread. And we have both, both kinds are pretty common. All right, so the working set, I just explained that, that's just the set of memory locations that are used in a small amount of time. All right, so the lesson from this is that context switching these days seem to depend mostly on memory access patterns, caching, working set and a whole lot less on sort of the intrinsic differences between processes and threads, yeah? No, that's the difference. That's slightly faster, sorry, 100 nanoseconds difference. I'm sorry if you don't, I'm sorry if that wasn't clear, that's the difference. So it's slightly faster because the basic context switching time is three to four microseconds, so the difference is about 3%. All right, so, all right, but there's a big caveat and we got into this already, which is many processes are multi-threaded. So, and we have to be a bit careful what we mean by a context switch for one of those processes, that's more typically called suspending the process, like if you actually take all the threads out of the runnable state, then you're really doing 30 or 100 thread context switches, and that's often orders of magnitude slower than single threading. So, yeah, here's just a snapshot of my Windows box with the top process and then the number of threads, so you can see that a lot of the processes really are running lots of threads. What it doesn't show though is you get down here, there's a lot of single threaded processes too. So, the ones down there context switch really fast. These ones are actually rarely, you know, the process itself is not really being switched in and out much, it's just coming in and the threads are being managed. The operation at the process level is called suspending and that doesn't happen nearly as often. And usually there's a special reason for doing it. Is that clear? Yeah. Yeah. Not in any, no, pretty much their process context and maps would be sitting in memory and their threads would be actually, the threads would be in a runnable or ready state in memory. So really all of this stuff would be sitting in memory most of the time. Only a small number of these would actually be active though. Yeah, well again, stuff that's actually listed as running is normally sitting in memory, taking up some memory. Well, yeah, exactly this much. So yeah, so processes that are active are consuming memory even if they're not, processes that are not suspended doesn't imply they're actually running, the threads are running, but when they're active, yeah, they're consuming memory. And a lot of the impact on memory these days is coming from the huge number of processes that people have, very few of which are actually doing real work most of the time. Yeah? Well, not on a multi-core processor, so K of them will be running if you have K cores or 2K. No, no, you can, because each of these is in effect running in a virtual machine, your OS can be running a thread from one process and a thread from another process. You don't have to, because you can't run all of these at the same time anyway, so you've got to sort of pick and choose. Okay, all right, so we did a classification last time of operating systems based on number of address spaces, which is basically a number of processes. And then, whether or not they supported multiple threads per address space, in other words, multiple threads per process. So early operating systems only had a single thread, really, so not even really processes. A lot of embedded systems emphasize threads over processes, so they're running sort of really just one process that has many threads in order to minimize the consumption of memory. As you can see, the Windows box I showed you is consuming tons of memory from these processes that all have disjoint memory blocks. When you only have a little bit of memory, that's not a good idea, so embedded systems tend to just have the one address space with lots of threads in it. So older Unixes tend to have the single threaded processes in them. But now, almost every operating system has processes that support many different threads. All right, so it's starting to become clear. Okay, let's see, thread state. And so threads, when they're running in a process, they share all of the IO and memory. So in particular, any kind of global variables, constant memory heap is shared across all of the threads, and the IO state is as well. By design, it's done that way. On the other hand, we already talked about the thread control block and registers, which are also, by the way, stored in the thread control block when you're saving the thread. But what about the stack? Well, you know what a stack is, but where does that live? Go ahead. Yes, it does. No, no, no, no, no, the process has multiple, if a process has multiple threads, it has multiple stacks. That's on the next slide. There's no simple answer to that question. You just have to figure out some scheme for doing that. So, you know, a stack, it contains the local variables, arguments to functions, and also program counters, typically also frame pointers. So it's stuff that's essentially the complete state of each function call. So let's quickly review that. So we have some code up here with a few functions calling each other, and then if we work through the instructions in that code, and then look at the stack on the right-hand side. Initially, when we call that function A, it should have the argument into the parameter temp, and then it also typically has some memory allocated, a stack memory allocated for the return value. You haven't generated the return value, but you need to save that space in case this function wants to call something else. You need to be able to save that space and write it later on. All right, so then we do some another call. So the stack grows now. Oh yeah, and I guess we've got a return, excuse me, we've got a return address too, which is a program counter value. So in fact, I guess we, yeah, no, I'm sorry, I mixed things up, the ret is an address since these functions aren't returning anything. If they were returning something, you needed extra location, okay. So we call C, and because these functions take no arguments, have no local variables, all that we're putting on the stack is the return program counter addresses. So let's see, whoops, A2 actually did have an argument. So when we push that frame associated with that call, then A gets the argument temp. And so this is a recursive function, you can see we're back to calling A again in a nested call. This time no temp is not meeting the test, and so there won't be a recursive call. We'll just print something and then start returning. So as we return from A, we pop that frame of A back off the stack, and simply as we return from C, that one comes off, return from B, that one disappears, and then A disappears. So hopefully that's all familiar. So imagine we wrote a program that was a, thorough calculation of the digits of pi, and it would save all the digits of pi in the file pi.x. What's the problem with this program as written? What's that? Yes. So what's the downside of that? So the first one won't finish, and if we wanted to print the glass list, we won't get to it. All right, so yeah, so the behavior you described is correct. Basically we'll keep running. And we have, in other words, a massive task. In fact, an unbounded task that's running before a simple task.  So that's shown schematically here. So we'd like to create a thread to run the first calculation. When you create a thread or fork a thread that call to fork the thread will return immediately and then you execute the second piece of code while the first thread is still executing. All right, so create thread is, we'll get into this more next time, but it's gonna actually create a whole copy of the current process, make some modifications to it and then run that. So that starts an independent thread and you can figure out what happens here, right? Both calculations run, which we'll get our second calculation completing quickly long before the first one does. All right, so whether or not we have multiple physical CPUs, it behaves as though we had basically two different CPUs executing the code at the same time, okay? All right, so here we're getting into the details of these stacks. So here's the memory space for the process. We have two registers which are in the two virtual CPUs. We don't see them here, but what's in memory is, you know, we said everything's shared between the two threads, so all of this is common, but the stacks are not shared. So in fact, we have to pick somehow two blocks of memory to allocate to those two stacks. So that's a complication of multi-threaded programming. That's the most significant complication. Those two stacks can't just simply grow in the opposite, or they can't both grow in the opposite direction as the heap as you would with the single threaded process. With single threaded process, you don't worry about how to dig to make the heap or the stack because you'll basically use everything until you run out. Here, though, you've got to decide where to put the second stack. And it gives you more vulnerabilities to running out of memory sooner. And in fact, in general, for complex processes, I guess Firefox and so on, you had about 50 of them to situate in your memory space. So that's an open question. There's no simple answer, but you have to somehow make some balance on the size of those stacks. In general, it's good to avoid heavily recursive functions because those are the things that are gonna chew up a lot of stack space. It's also good to avoid very large local variable arrays because those also use a massive amount of stack, yeah. All right, so that's a good question. So should we actually, well, it doesn't quite solve the problem. It's a protection step more than a resource step in the sense that you'd have to make the commitment for each virtual memory view. Like for one thread, you'd have to say here's, well, it does, actually, there's a few complexities to doing that. You could make a commitment that only a certain thread could see one of these stack areas and write to it. But that implies that that thread then has a different map from the other thread, right? And it also applies that you have, it implies that you have to make a commitment in your memory map as to which blocks are the stack blocks. So it doesn't, it helps in terms of protection in that you can avoid thread one stack crashing into thread two. That would probably not have, that would probably be throwing an exception anyway, even with a simpler scheme where they're in the same address space. But yeah, but the big penalty with that is that you've turned your threads into sort of almost process in that they have to somehow have this additional state that knows which is the stacks associated with which thread. So there's sort of a complexity penalty to doing that, yeah. I didn't quite get all of that question. The, yeah. Well, no, that's by definition not happening. I mean, each thread has the same address space. If you have a program or a process with multiple threads, they all see the same address space. Well, but you still need to have them, give them distinct stacks somehow. Although they can see each other's stack, but they're only using one of the, one of those regions for their own stack. So that's a necessity. And you know, you probably would have a protection layer for each thread to prevent them from riding either out, either outside their own area or perhaps into the heat. But anyway, it is more complicated than what we've talked about. The good side of this is that because the stack state is just sitting in memory, you don't have to do anything when you context switch. It's just, it's just sitting there. Thread number two doesn't do anything. I get, it's not quite true. It has to save its stack pointer in its thread control block. That's all it has to do. Actually, yeah, that's all it has to do. All right. Okay, so here's the thread control block. And it contains, it only needs to contain the CPU registered program counter and the stack pointer for that thread. Yeah, there's other stuff to do with its thread priority and so on. It's share of CPU time and so on. Stuff that the operating system uses in order to choose how to schedule it. Yeah, there's a little bit of extra stuff and we'll see why we need this very shortly. When the thread's not actually running, it has to go in a ready queue and this stuff contains data about which queue to go into and where it is exactly. Also probably a link list of other threads. Okay, pointed to the enclosing process control block or PEB and other stuff. Yeah, so the TCBs are in a protected area of memory that only the kernel can access to make sure that they don't get damaged because they would severely corrupt the whole running system if they were. Okay. All right. So last time we looked at the running lifetime of threads and just quickly they start off being created first and before they can actually be run, they go into some queue somewhere. That's it when they're in the ready state. They can then actually be run until some either interrupt or some kind of yield or halt happens. Then they go back into a waiting state or if they're just simply interrupted, they would go back into the ready state. If they're just interrupted by VOS. And finally they'll be terminated at some point. So the idea for implementing this is the ready queue. So if you think about it, if you look at that picture I showed you earlier of my task manager, if you actually counted all the threads, there's hundreds, probably thousands of them. So clearly most of them are actually not running at a given time. There's maybe eight of them running. The others are sitting in the ready state. So we have these hundreds or thousands of processes to manage and so we use ready queues to do that. We want to manage them in some way that they can basically instantly swap back in independent of how many there are. All right. So the idea of the context switch for a single threaded process or a thread doesn't really apply to a multi-threaded process. Again, that's the suspending operation which is really quite different. Suspending a multi-threaded process does mean, it actually means typically unloading all of the thread information from memory. So it's a much more massive step but it also doesn't happen much. Most of the time the process, the whole process is read into memory and its threads are just put into ready queues. So that's really the threads that are getting switched not the process for a multi-threaded process which is also the consequences that the multi-threaded process just sits there reading memory. All right, so most threads are in a ready state but there's a lot of them. We want to make sure that we can swap them back in basically in constant time. And so we use these scheduling queues and so you can think of those as kind of a bunch of workers, they're in a ready state but they're also arranged in a queue so they can conveniently spring to action when there's a task. All right, so there's typically a bunch of ready queues in fact and the ready queues are organized very often by a particular resource that could be causing a wait or essentially releasing a wait. So there could be a basic ready queue of things sort of just ready based on the operating system. So those things are not really waiting on anything, they're just runnable looking for a chunk of CPU to run. So all right, so that's simply a link list and you'll typically take the first element of the link list, swap it in, take another running process, swap it out and then put it at the end of the link list. So yeah, you use a link list with a tail pointer so that you can pull from the front and add to the back. I mean, it's a queue, right? I shouldn't say link list, it's a queue. Similarly, well, some things you may not be waiting on them or you may not have any, excuse me, any threads that are waiting on that resource and so that queue is empty. The disk very often will have stuff waiting on it and again we have this queue of processes or threads and we can basically pull from the head of that and then push on the tail when we swap something out. Okay, and similarly, ethernet. So is that making sense? So that way, the reason it's done this way is if let's say, if you had a single queue and for instance, one of these events freed up or swapped out a task, you'd have to look through the single list to find the next task that's waiting on that resource. So this way, you don't have to do any traversal of the lists in order to find the next runnable thing. Yeah, yeah, I'm sure those kind of things can happen. Yeah, I mean, right, if you're running, that's right. Yeah, if the operating system determines that you're currently running, yeah, I guess I shouldn't probably, once the process goes into the operating system, it's no longer really associated with any of these things. Basically, something stops the process that the OS is currently running and when it stops, then the OS should know which queue to put it in. So it's basically, yeah, so this is just for the purposes of maintaining a queue such that the appropriate event will trigger the appropriate next process. Yeah, well, the idea is simply that you want to be able to maintain a queue, which means in order to be fair, I'd like to be able to give every one of these things a turn, which means I wanna pull from one end and add to the other end so that if I keep doing that, everything will get the same amount of time actually running. Okay, so, all right, just to remind you, once again, a project signup is due by tomorrow. And make sure all of your class account names are in the application form. Select please three times, here's our section times again. And you should attend a section this week so there'd be only two left now, so make sure you attend one of the ones tomorrow if you haven't already been to one. Was there a question? Yeah, no, no, no, no. I mean, the queues are just the utility that the CPU is gonna use. They're not directly processing or dealing with interrupts or states. The operating system will have a trap sent to it from either a disk event or a running program that says yield because I'm waiting for something. Then the operating system can say, all right, here's the process, I'm gonna suspend this process, but what am I gonna do with it? Well, it's waiting on the ethernet, so I'm gonna stick it at the end of this queue. So in a different, okay, that's one kind of trap which is sort of a yield trap. The other kind of system call that it'll get is that the ethernet is currently is just cleared, is the buffer is empty. So when it gets that kind of trap, it says, oh, look, I can run another thing or similarly with disk, it'll get a trap that says the buffer is free now. When it gets that kind of trap, it says, okay, and if in addition it has a slot to schedule something, it can take an appropriate task from the queue associated with that kind of resource freeing event and then schedule that. Or even if I guess, you know, and if there isn't a slot to schedule, it may decide to preempt or it may wait a little while and then preempt a running process so that that available resource can be used. Yeah. No, the operating system wouldn't know anything about what's gonna happen. It's just, it knows nothing. But whenever something does happen, it's inevitably, it's made known to the operating system through a system call or an interrupt. And those are always specific to a device. So it's always sort of processing this, the set of events which are may or may not be associated with threads, right? Some events are not associated with threads, they're just, this device is buffer is empty. So then it can typically use this thing to find threads that would care about that. Sometimes though the events do come from system calls from particular threads. And in that case, from the type of the event, that's how it determines where to put that thread if it's suspended. So it's really a few different cases. But there should always be plenty of information for the operating system to decide what to do. All right, so, all right. So we're at the break time, so let's take a five minute break and we'll finish up after that. Okay, let's continue. And before we get going again, I just wanna point out that I misread this day. I'm sorry, this is not Thursday. From this distance, maybe the font's not big enough. But anyway, so I'm sorry, but the sections are all Tuesdays and Wednesdays, so you had to already attend one this week. Sorry about that. Okay. All right, so let's now try to make the operating system scheduling more concrete. We'll give a very simple picture this time because later on we're gonna explain different strategies that operating systems use in order to provide various guarantees. But for now, let's just look at the basic function. Okay, so the operating system, the basic loop is to run a thread. You know, let's just say you start a very first thread. Then choose the next thread to run. So that's the sort of switching operation. Save the state of the current thread and load the state of the CPU. So that's basically one traversal of that, the thread PCB saving diagram that we had earlier as traversing from one to the other. And it's an ongoing loop. So that's the main function arguably that the OS does. It switches from one thread to another or one single process to another. So if you wanna start running a thread, we covered that a little bit.  Where does the process control block come from the first time? Well, a lot of the information is often encoded in an executable binary. So the binary is typically contained programs and data, but they'll also contain any initialization of registers. So there's sort of a precursor of the process control block and thread control block that's encoded right in an executable. So you use that information to initialize the registers. And if it's a process, you'll also have to initialize all of the other virtual resources, the memory and the IO devices. And then from the initial data, so the executable, among other things, will always contain a start location, a start address to run, which you load into the program counter and then run. That's the entry point of the program. So by now you have lots of ideas about, so how does the dispatcher get control back? Quickly, what are some ways it gets? How does the OS get control back, yeah? Right, and specifically what is the IO? Yeah, but okay, that could be a couple of different ways. What does it mean IO? How does, what physically happens in the machine? Well, I mean, for it to get to the OS, it has to somehow have either a trap and exception or an interrupt, physical interrupt. So the computer, some wire has to get, yeah, or a yield, exactly, right. So the yield is a software instruction in the program that will typically cause a system call as well. Yeah, so we'll get more into that, but it does a sort of a special kind of call, function call, which also has the effect of doing things like priority switching. Okay, so all right, so we have some of these events. The yield and we have other kinds of interrupt events which can preempt the threads. All right, so let's see, internal events, waiting for some IO, also when the IO becomes free, that also triggers an event. Signalling is a mechanism that's a low-level mechanism for communication between threads and the yield, which is an important one, which is a friendly way of giving resources back to the operating system in your program when you've realized that you're in a waiting state. And actually compute pi, this is a nice version of compute pi where it computes the digit and then returns control to the OS. So early operating systems including Windows 3.1 and even DOS had a facility for something like multitasking by having lots of yield instructions in things like spreadsheet code. Since it had no real threads, the application code always had to call yield so that the operating system could start. Okay, so in our simplified view of the world of processes and threads, we said the threads only had one, there was one stack per thread. In practice there's usually at least two, at least in Linux. The reason is that we want very different protection on user code and user state from kernel state. So in fact, user code's running with it, usually a separate stack from kernel code. So when there's a trap issued, let's say from a call to yield, the trap will actually trigger an interrupt and the interrupt handler is gonna actually switch the stack pointer as well and move to a kernel stack. And that way you can protect the operating, again some of the critical resources, namely the stack state of the kernel from bad user code. All right. So now we're back in the kernel and we'd like to get to the other thread. So we've worked through some of how this happens to do with the queues. So depending on what event brought us in here, we can choose an appropriate thread that might be waiting on some resource that we've just learned is free. So we pick that new thread and then we do the switch, which is pushing out the old process control block or thread control block and reading in a new one and then also flip the program counter. Okay. Yeah, and this is the bit of subtlety that I don't really think we wanna get into right now, but usually there's some cleanup that happens later on. Even if this current thread is ready to be killed, we don't usually kill it right away. I'll get into that later. Yeah, there's a special thread that should do the cleanup because if we just do the context switch without the cleanup we'll actually give better performance to the next thread. Lower latency. Okay. So and it's part of switching. We want to save the state of the old thread and that's what's going into the TCB or PCB and then we'll read in the new one. So again, here's the picture. If we have a first thread goes along and calls yield that causes a trap, which then starts the kernel code which starts with its own stack. And as part of the switch, we do an actual, we reload the CPU registers and when we load the program counter that's when the code actually starts executing the other thread. All right, and suppose that other piece of code calls A first, which calls B which comes down and calls yield which causes a trap back into kernel code does the preamble and sets things up to do the switch and then goes back to the user code. Yeah, I mean, this is not very clear. It's going back all the way to the top to the user stack and the user code. Okay, is that clear? Yeah. Yeah. Oh, I see, I mean what happens to the, let's see, let me think. Yeah, so where does that get cleaned up? So because, yeah, all right, so we're not actually calling A again. We're entering back here. So in a sense, the stack pointer is going to point to the top of A but the program pointer is going to point back here again. Does that make sense? So yeah, because once these stacks are set up, we're not, you know, how can I put this? We're not making recursive calls where our program pointer doesn't go back to the start of A after the first call. Maybe I should have made, I was assuming that the context which here starts off at the beginning of the second thread, by the time we come back to the first thread, we're coming back, program counter right here. So it's not allocating anymore on the stack. We're just gonna be shuttling back and forth between those two states. The kernel code though, this does have to get removed each time. So part of the switch is to basically execute a pop or a return.  So it clears this stack and then starts running the other piece of user code so that the next time we come down to yield, it will make another call and create a new stack frame for the kernel yield. But when it does that, it'll have a clear stack. So the cleanup code or rather the switch code itself is implemented as a special kind of a kind of return slash call that's gonna clear that red stack frame. Probably should have shown that on the animation. Okay, anyway, is that making sense? All right, so let's quickly examine some of the hardware details behind interrupts. So interrupts are really physical events, electrical signals that happen in the hardware, triggered by things like data becoming available or data having been completely written or mouse keyboard events and so on. So those trigger transitions in the hardware. The IO hardware on the chips recognizes those as interrupt events and associated with those events typically as special addresses, interrupt vector addresses and then in the often actually in the standard memory these days there, each vector is associated with a particular program counter. So in other words, it allows the interrupt to turn into a system call. So part of that, an important part of keeping everything running smoothly though is the priority system so that high priority events can create lower priority interrupts but not vice versa. Because the interrupt triggers something that's like a system call, it may take some time to return from that call. So the, yeah, so interrupts have priority, they also actually have masks as well. So you have the ability to turn off interrupts while you're processing other interrupts. Sometimes you might have a low priority interrupt that has a critical section, so it can't be interrupted and you'll implement that by masking out the other interrupts, which turns them all off. Normally though, you'd like to leave the higher priority interrupt lines enabled so that they can interrupt you. All right, and the priority encoder picks the highest enabled interrupt. Usually they're coming at different times which means it will execute a high priority interrupt, higher priority one than what's currently active. On the other hand, if an interrupt comes in that's lower in priority than the currently running interrupt, it won't execute until that one finishes. So I think, yeah, and there's usually a global interrupt, a GIE flag, and there's also usually non-interruptible, non-maskable interrupts that make sure that, for instance, critical timers can keep running and keep watchdog code running, especially in real-time systems to make sure that some part of the kernel is always going. So in a preemptive operating system there's a particular type of interrupt that's really important, which is timer-driven interrupts because they're guaranteed to always be happening at regular intervals and they're guaranteed that you always periodically go into the kernel to at least do scheduling and at least keep your runnable processes running. So the periodic housekeeping also, by the way, will include cleaning up processes that are no longer running and so on. And they'll go back and start running new runnable threads. It's called preemptive multithreading because the operating system via the timer interrupts preempting and interrupting running code. Non-preemptive multitasking is the kind that we talked about earlier where, for instance, in MS-DOS, the spreadsheet programs periodically call yield and give control back at appropriate times. Obviously, though, that assumes that code's extremely well-behaved, which no one expects these days. So preemptive multitasking guarantees that even bad codes being interrupted and allowing you to run good code periodically, yeah. No, almost never does a compiler insert any yield statements. Among other things, it wouldn't work unless those yield statements are executed close together in time and it's undecidable how long it'll take between one call and another. So people do use it in real-time systems sometimes. You just put a lot of yields in so that it can increase sometimes the quality. What it helps do is that putting yields in appropriate places makes it less likely that there's an interrupt in an inappropriate place. So it's often a good strategy for real-time. Okay, was there another question? Yeah? Well, I mean, this kind of timer, it's probably 10 milliseconds or 50 milliseconds, something like that. And it's just gonna slice between different runnable processes. So because it's preemptive, if you have a program that's trying to run for 30 seconds, it's just gonna dice it up into little chunks. Okay, so the idea of threads was to have better cooperation within runnable processes. So that assumes that they cooperate with each other and don't compete too much. It does allow you to share resources. And for instance, it's sometimes simplifies programming substantially by not requiring you to have to replicate data that's used to service different, say different user events. So all right, so the threads help you share resources. You don't have to replicate them for different clients being serviced. Sometimes they also speed things up. They also push some of the resource management into the application code, which can be good for performance. Okay. All right, so if you imagine we wanted to build a threaded web server, it would have a loop like this, which is basically accept connections. So in a TCP system, normally you create a listener first on the server which can accept client connections. Once you receive a connection, there'll be a connection object returned by that call. It'll block until it gets one. Once you receive that, then you can start a process to handle that connection with the user. And thread create, because it spawns a thread, returns immediately and allows you to go back in the loop and listen again for a connection. So the main thread here is always running and always listening. Whenever it gets a client connection that needs significant time, though, spent to service that connection, it spawns a separate thread to do that. Okay. And so an advantage of doing things this way versus trying to do a process version is that here we don't know ahead of time how many processes we might need. And we'd be trying to create processes each time. And even though processes and threads have similar switching times, the creation's very different. Again, remember that to create a process, you've got to create this whole virtual machine, initialize a big chunk of memory and so on. So that would be really expensive. And you can't easily sort of anticipate how much you'll need. And even if you did, you don't know how many resources the particular processes would need. Very difficult. The threaded version doesn't have that problem and it can adaptively decide how much memory it needs for each client as it goes along. So it's cheaper and it uses memory more efficiently. All right, so the last idea is thread pools, which are a way to basically create a better match between the number of threads that you desire and the number that can physically run on the machine. So thread pools are basically separate the number of sort of running active threads from the number that you would like to run by creating something called a thread pool. All right, well, we're right at the limit here. This is the last example and we just have to look at this one online, I guess. But it's similar to what we looked at before. So you receive a request and then process the request for an update. And each of these service requests might process IO in order to speed it up, we add a thread instead of sequentially doing the operations. There's the thread there. Oh yeah, all right, we're getting into currency now. All right, sorry. So I think we'll perhaps go over this next time, but threads create an additional problem, which is a synchrony, because they can execute in different orders. Sorry, I'll finish that next time.


My name is Allie, I'm a volunteer at the Langmuir and Fire Brigade with the CFA. I'm also currently a law student at Deakin University in Berwood. I joined the CFA roughly about two years ago. I think what really sparked the interest in the beginning was my dad had been a volunteer for so long and he used to come home from jobs and before I'd even let him sit back down and quiz him with 101 questions of where he had been, what he had done, who went on the track with him, did they go code one, code three? So I always really had that interest and then when I finished high school I decided I'd give it a go. So I sent in my application and did my minimum skills and since then I've loved it. I've done a few different courses like BA, breathing apparatus and low structure, probably a couple of the biggest ones I've done. I've also done a few smaller courses like fire safe kids. That's been a great course because it's meant that when we go to schools or schools come here I'm able to teach children about fire safety. The standout trainings that I've done has been my breathing apparatus. The BA was a very challenging one for me it was something I'd never done before so I loved that now whenever there's a job where there's an opportunity to put the set on my back I'm the first to put my hand off and say I'll do it. One of the first fires I attended was just a little bin fire down at the local football club. One of the guys on the track he was our captain he said to everyone on the track just you know let Ali do her thing and she can run the job I want to see what she does so I did I got everything set up and straight away put the straight jet onto the melting plastic which he expected I would do so they all got a good laugh out of that and then I guess one of the other big jobs I've been to was a big bushfire down at the Seaford football club that was a very confronting job because again nothing like I'd ever done before as soon as I jumped off the truck smoke just hit you straight away I started watering no start watering but it was great there was lots of different brigades there I got tasked with a couple of guys from some neighbouring brigades and we did some blacking out so it was great to pretty much put all the skills I'd learned in minimum skills into practice got to use the knapsack and the Rayco and yeah I guess those would probably be the first couple of jobs that stood out. Balancing the CFA and uni can be quite hard because they are huge commitments it does require a lot of prior organising I need to have a diary that I like to plan probably at least four weeks in advance of what I'll be doing it does require a lot of flexibility as well people at the brigade are really good they're really supportive especially when it comes to exam time if I have to cut back a bit on turning out or making training they're really understanding but also my university holidays coincides with CFA's busiest season which is the summer season so I get to redeem myself then and jump on the truck as much as I can when and when all the jobs start coming through. I guess about halfway through high school towards the end of year nine I really started applying myself to my studies and I ended up finishing year 12 with a really good score so it was sort of a last minute decision that I was like okay I'll give Laura a go so I wasn't exactly sure of what I wanted to go into but since doing that I've found that being the volunteer in the CFA has helped so much especially things like getting work experience and now that I've started to become towards the end of my degree I've really become conscious of building up experience and networking it's been great I'm having the CFA is something to put on my resume it's definitely something that sets me apart from other applicants it's a really unique thing to be able to say I'm a CFA volunteer in the interview it's something that always gets brought up and then just job skills as well like employees love it the character building aspects of being in the CFA the leadership and the discipline the teamwork also being able to think of my feet and look adversity in the eye and just go okay this is what we need to do those sort of things employers love and it's something that I can sort of use the CFA to demonstrate how I've got those skills also something like the scribing that I've done a few times here at the CFA has also really transferred over in university so that skill of being able to write really quickly has really helped in our university especially law exams your to our exam you do not stop writing in also through my time with the CFA I sort of sought out the CFA legal counsel that work at headquarters I was able to use some connections to get their number and so I just gave them a call and said hey could I come in and do some work experience so I'm due to do that in the next couple of weeks again that's something that the CFA has helped in my outside life friends at uni I think they love it or at least I think they like hearing all the stories that I come to uni with if I've been to a house fire or something like that the night before I get to uni tell them all about it I think they think it's pretty cool again it's something that's unique I mean I don't really know that there'd be many at my university that do it or in my course especially some of the guys they all say oh yeah I'd love to do that one day so definitely something that you know is an interesting conversation starter I guess the advice I would give is just give it a go being a female and a young person as well I don't fit into the stereotype of what a firefighter is in the CFA but I just gave it a go I always knew in the back of my mind that I've got nothing to lose if I don't like it then I don't have to continue there's nothing locked in about it and by just giving it a go I've found that I've loved it it's been such a great experience for me it's been so character-building and I've met some incredible people some of my closest friendships from the CFA and from my brigade I guess it's hard to put it into words exactly what it's going to be like yeah my advice would just be you've got nothing to lose give it a go


Hello everyone, so we're entering Val d'Avurre, which is a part of some previous editions of Lagarde which I have been keen to try out for some Actually since I decided to try out the first time Lagarde I have wanted to come here and try it out So let's see how much painful it is


Okay, so let's try this titration problem. So we're finding the pH during a weak acid, strong base titration, and this portion of the problem is before any base has been added. So hopefully you can see zero mills. So it says calculate the pH during the titration of 40 mills of propionic acid. Propionic acid, the k of it is 1.3 times 10 to the negative 5th after the following volumes of 0.10000 molar in AOH is added. And this first one is zero mills. So since there's no mills of hydroxide being added, this is just like doing a weak acid solution problem. So how do we do that? We have to figure out what the reaction equation is and then set up an ice table. There's actually, you know the quick and dirty way to do this, but we're going to do the whole shebang at this point. So first things first, right out of your acid, plus water, plus back and forth. Everybody OK with that? So remember this is we're able to remove x because k-h is very small, so 5% rule. So I'm going to erase the whole table. Is that OK? I'm just going to keep these values down there and then I'm going to write k-h out, OK? So can I do that if everybody got this done? OK. So what did we say? 5% allows us to do that. So k-h equals concentration of the conjugate base, H3O plus divided by an acid. So we're going to solve for, remember this is x and this is x, so we're going to solve for x squared here, OK? So when we do that and we solve for x squared and we take the square root of that, right? That is solving for H3O plus. Is everybody OK with that? Can I do that in one step or should I do both steps? Well, some people want to do both, so we'll do them in both, OK? So we're going to rearrange this and take this up to here, OK? And then these two both equal x, OK? So I'm going to erase these guys. Those are x's, so x and x. So we're going to plug in x squared for that, OK? So when we do that, right? That means this is x and this is x. So if we take the square root of that, then H3O plus equals the square root, right? Does that make sense? So H3O plus is going to equal the square root of k-h times the concentration of CH3CH2CO like that, k to the 5, concentration, 0.100, so 1.3 times 10 to the negative 6. So I get 1.1 times 10 to the negative 3 molar. Is everybody OK with that? So the pH, I'm going to erase this. pH, negative log of the H3O plus concentration, which is the negative log of 1.1 times 10 to the negative 3, 2. So that's the pH of the solution before any acid is added, or any base is added. Only the weak acid. So it's just like you would do a normal weak acid solution. OK? Are there any questions before I kill this one? That's the right one. Alex, that's 2.959. Oh, OK. Any other questions?


What's up everybody and welcome to yet another edition of the Falcons final whistle podcast. I'm Scott bear Looking into a zoom with Tori Mcalandy and Ashton Edmonds on the other side, which normally doesn't happen for home games But I left the podcast gear in my car because I have the memory of the bold fish and it was too lazy to go back and get it So here we are. Thank you technology for bringing us all together We're literally in different press boxes like I can see Tori and I can't see Ashton, but he's down there somewhere Nonetheless We are coming to you after another tough loss man. This one was Pittsburgh 19 Falcon 16 It was a loss at home There was a yet another golden opportunity for the Falcons to get a win They ended up for the second straight week ending their comeback attempt with an interception by Marcus Mariota Last week against Washington. It was on I believe the two or four yard line Picked in the end in the four then the four batted pass on this one. It was that the Falcons to and Marcus Through a pick that ultimately ended a comeback attempt the Falcons lose another one. They're now five and eight Five and eight. There's still somehow within striking distance of the NFC south I know when no one wants to hear playoffs and we'll explain why I Think as Ashton pointed out last week and kind of sparked a column idea for me Is that they're not playing like a playoff team or a playoff contender? So we're gonna get to all that And we're obviously gonna talk quarterback. How can we not talk quarterback? It's what all of you want to hear about it's what all you all all of you want to discuss and we are podcasters for the people We're gonna talk lots of quarterback giving up before we do that though. We're gonna do I don't know. I always like to say general takeaways But Tori your thoughts on this Steelers loss in particular. Where did it get funky? Um, I mean, I think it started out funky. I mean the When I look at what this offensive production was I think I could argue that this is one of the least productive Games offensively the Falcons have had and it's not even necessarily yards because I do think they had some good explosives It was absolutely getting in the red zone and scoring touchdowns. That was something that was so fascinating to me when we're watching this game is One how poorly the Falcons did on third down that's I mean stats can tell you that story But also just the fact that the Falcons did not get into the red zone until late in the third quarter I'm talking really late in the third quarter and that to me if you're it doesn't matter Well, I say that it does matter what your defense is doing But when you as an offense are unable to move the ball into the red zone to at least give yourself an opportunity To put points on the board That is setting up your entire team to kind of just it makes it think so much harder on your defensive unit and your special teams unit When your offensive unit is not Producing points and I think that was kind of one of the major takeaways that I took I thought the Falcons did have opportunities. I just didn't think that they I mean there were two Maybe even three drives Within the course of the first half and even the first part of the first quarter Where the Falcons started the drive off with a huge explosive play And then nothing came from that they couldn't get into the red zone After that and so after flipping the field on the first play from scrimmage. So That is kind of what my major takeaway was when I look back at this game It's just how this offense it never felt like it ever got going in the way that it needed to Ashton you were in the post game locker room and you kind of in the in the story that you wrote on Atlanta Falcons.com You kind of described the mood in there and and the reaction to that loss kind of Pain a word picture for us about what that locker room was like Well, first when I walked in it was around eight players eight nine players. Most of the players had already left Um, but you know when I walked in everybody was just it was just quiet in the whole locker room It was quiet and nobody was really talking Um, and you know players, you know when I did walk up to Richawn Evans and we were talking Um, you know, he he you could tell that the emotions were you know, they were heavy on him and um He spoke confidently, but it's like He also spoke optimistically, but he also you could tell that, you know These past two weeks the washington game and uh today's game against the stillers, you know, it was tough for the whole team Um, and you know, that's but that was the gist of what rashaun was basically saying Same with talla alger. You know, he was he was saying that this loss was tough. Um, 19 and 16 It was a three-point game that could have went the other way. Um, you know, but things just didn't Pan out that way. So You know, just to paint that picture it was Yeah, it was quiet. Um, you know players Where you could tell players were down about this loss. Um, and you know That was that's really it for the most part Tori, let's all move on here to the quarterback I don't know what the proper word is situation probably isn't it but nonetheless, um We have to talk about the quarterback because Their arthur smith and marcus marriota were asked about the possibility of a quarterback change Coming up the falcons have a bi week next week and then they played the new warland saints in the big easy so, um, they were asked about it before we get into and and that's why this is such a A big topic of this podcast So why don't you kind of set the stage for us about what arthur and what marcus said after a game where marriota Missed some throws missed some opportunities and open targets and ultimately got picked off on that final comeback attempt Yeah, I think from Being there and listening to what arthur smith and marcus marriota said after the game arthur smith specifically I think we kind of have made it to a fork in the road in terms of This quarterback situation and I will say situation. I know if this is three weeks ago arthur smith says there's no quarterback situation But we're not three weeks ago And that was something that I spent a lot of time in my post game article kind of almost like comparing and contrasting arthur smith's responses to quarterback related questions after the carolina loss versus the The same similar type of questions asked of him after this loss against the stealers and how they differ If you go back and you listen to and read the transcript of what arthur smith said after the loss to carolina There was a lot of deflection. There was a lot of deflection away from marcus and Even at one point it was like the third question about the quarterback and and all that kind of stuff and Arthur smith even point blank said, you know guys, you're making this about the quarterback But what about the team? We should have protected better. We should have run the ball better We should have done x y and z better He listed all of these things that the falcons should have Done better in that loss to carolina now fast forward to where we are In week 13 about to go into a bye week And those responses are different when arthur smith is point blank asked Are you going to make a change at quarterback or are you planning on potentially doing something different at quarterback? He essentially doesn't deflect at all and he says there is a lot to evaluate Every option is on the table And it's a good thing that the bye week is coming up It's a good thing for us as a team that the bye week is coming up and I think That response even in its vagueness The fact that it differs so heavily from what it was against the care against carolina or after that game and even after that game and into the next week Where again arthur smith has point blank point blank asked about the quarterback situation and he says quote There is no situation. I don't think the same could be said About where they are now. I do think that they are going into the bye week to evaluate this position I think I believe arthur smith when he says that there are changes coming and he said that not in the way of a The specific quarterback position he said that as a team as a whole but you have to think that This quarterback position is going to be heavily evaluated Over the course of the bye week and I think that what I would like to see and this is just me my opinion What I would like to see is regardless of What happens? Whether you decide to stick with marcus or you decide to give desmond a shot I think arthur smith should come in on the monday before they play the sains and say one way or another Because I feel like if you are going to make a move to desmond ridder to see what you have In him my opinion is that you either do it now Or you potentially don't have another opportunity to do it You have two weeks of prep coming up You have an entire bye week and then an entire week of practice before heading down to new Orleans to face the sains My opinion is if you are going to make the move now is the time to make that move Now again, that is my opinion. We don't know what they're going to do We don't know what these evaluations over the course of the next week are going to entail for this coaching staff But Whatever comes of it. I think arthur smiths should say One way or another that they're either sticking with marcus or they're going to give desmond a shot and hear the reasons why That is ultimately regardless of what decision they make that is what I would like to see happen Not monday when you're probably listening to this podcast, but after the after the bye week is done in the lead up to the sains game I gotta say that was like a fascinating breakdown Thank you. I hope that's fascinating in a good way No, yeah, I think that the biggest thing that I liked about it is that you can say kind of You can just make a blanket statement say well when he was asked about this before he slammed the door on it But it's different this time. Okay. Well, that's a thing for you to say But then to tangibly go back and look at the evidence and see that the evidence is different Another thing that I would like to say about arthur smith. Well, he's a very smart individual He's very good at press conferences and if he doesn't want to tell you something He's not going to tell you but he also tells you the truth in all of it You've got to learn how to like read the matrix with him So to compare and contrast what was said before and what was said again to question I'm sure he knew he was going to get right. Oh, yeah, and you see these differences in the answers. I think Shines a light on it. I also agree with you that There's going to be a lot of people The national guys are going to make a lot of phone calls a lot of people are going to be Trying to read into things. I think ultimately you've got to make a move. I don't believe That making denis allen Prepare for two guys makes that big of a difference, you know to try to like do it like old college way where they They lead right into like the opening kick and so I made a A choice and I do think if you're gonna I've always said if you're going to put Desmond Ritter in you put him in with the best possibility and chance to succeed That doesn't mean after the halftime break when the guy's been running the scout team all week. It doesn't mean that It doesn't mean Even after a thursday, it means giving him the opportunity to take enough first team reps to see what he See what what he can do with it. Arthur Smith was also asked Uh by uh, josh kindle of the athletic. He said Sometimes is making a change for change's sake when you're heading in the wrong direction Is that an option or is that something that you would consider? He said absolutely, right? The the thing that I so while I think it's possible that putting Desmond Ritter in considering his arm strength his athleticism his Um Ability his track record of performing well in the clutch. I think it could give this team a spark I would caution against even members of the ridder ruckus I would caution against making the absolute assumption that or making the assumption that it absolutely will He could play like a rookie and rookies make mistakes. They often make mistakes in key pressure pack situations Oh, by the way, New Orleans is super loud and hates the falcons and it's gonna be and if they somehow are in a Tithe or are in it in the division That crowd's gonna be nuts, right? So for all these reasons I don't think that you can just automatically assume well if they put Ritter in they will be better And I think even if he gives them a spark he will make mistakes and are you willing to Make that move When you're still in it, right and my rant is almost over ashton's almost returned. I'm really sorry Nonetheless when I look at it and I've always kind of had the opinion of one We don't know if desert ranger is good or not. We haven't seen in practice since the summer. He doesn't get a lot of Steam reps. Uh, we don't maybe he's great. Maybe he hasn't been good. We don't know But I always had kind of said that They wouldn't make a move or I didn't think they would make a move until they were mathematically eliminated from playoff contention I don't know if I hold that feeling anymore. Just like Arthur is was it different three weeks ago from now I'm answering it a little bit differently from now because the the hour is getting late the Desperation may be a setting in and after losing four or five the need to Lip things around or have the season fall by the wayside is now Right, so I'm not saying do I think they should do it or not? I'm just saying that I my opinion about it has changed since the panthers game Okay, so real quick hasn't it's been very very patient I know I know I I think too and this was something that I wrote about as well You talk about I was thinking about this whole thing about like time and how you are Essentially, and this is I mean, I do believe this to be true You are running out of time if you are the falcons to get an evaluation of desmond ridder Before you head into this coming off season where you essentially do have to make decisions as to where you want to go in a lot of positions, but especially at the quarterback position and Do you currently asking the question and having an answer to do you believe that the future? Franchise quarterback is on this roster in 2022 And I do think that you are running out of time to be able to answer that question Now again, I'm with you that it's just because like let's say they run desmond ridder out there against the saints that he's going to be Lord and savior That's not at all what we're saying here What we're saying is is can you get good evaluations? To decide what you want to do in the future because even though you are playing to win each and every game There is a whole side of the building that's job is to look ahead and figure out what this team looks like in 2024 2025 so big picture. I also think That has to go into this thought process as well. And I mean that's kind of just where My head's at too, and I'm sure that is you know, where a lot of people's heads are I think that's where a lot of people's heads have been even before the season started because I feel like we were we've we've been having this conversation since Marcus mario to signed here and desmond ridder was drafted You know and I was in just a piggyback. I mean, I feel like both of you all hit everything Like accurately, um, I would say just in my opinion. I think we have seen Um, you know, it's been it's week 13. We have seen Marcus mario to play And like you said like you both said if you're going to Make a decision like make it now. We have four more games left four critical games two division games and Two games against baltimore and in arizona, but I do think it's important To in my opinion to if we're going to see desmond ridder Yeah, he definitely has to play in these last four games and like tory mentioned like you want to see if this is a quarterback That you can have for the long term And like scott mentioned, you know, we we know desmond ridder's track record from college And you just never know, but I do think in my opinion If if a quarterback change is going to happen, it has to be now with four more games left in the season I look at it, especially these last few results, right? And I understand it's a team game and also that sometimes random things happen like Like diron pain shoving his hand up at the last second An interception in the end zone. There's some randomness. There's it's not all the quarterbacks fault There is also some give and take With marcus mariota that he does things that nobody else can do Just the truth. Sometimes that happens. Yeah, he's a high asmen trophy winner Like I think people forget that this guy knows how to win games. He's a good He's he's shown that he can be a gamer Right. The one thing about it that I think this team needs is the clutch gene Right somebody to just kind of make it happen And that doesn't you know, they were seven and two and one score games That doesn't necessarily mean matt ryan absolutely had it although I think he kind of does But they need the clutch gene and from his I'm not saying everything that happens in college applies to the pros But desmond ridder has proven to have the clutch gene Everyone will laugh at me because I'm going to bring up a pre-season game and pre-season games don't matter And it's against the fourth string, but against the lions He somehow wiggled and ran around on fourth down and nearly got his head chopped off and found a way to heave it to jared Bernhardt for a win. Okay, we don't care about the results. We understand that the competition's bad But he can do that stuff and he's good at that stuff So it that makes him an attractive option I also look at it right like we're trying to Build this this case and we're trying to debate things again without having all the puzzle pieces in front of us because maybe Although arthur complimented him about his kind of mental football acumen back in the summer But how's he doing in meetings? How's he doing in game plan? How can he do with the pre So many pre snap motions so much misdirection and selling things that needs to happen And is he good at some of the things that this offense already is you're not going to reinvent the wheel in week 14 I think all of these things need to go into your head as you're trying to evaluate What is going to be a major decision? It could be the thing and you have a bunch of different outcomes And that's why arthur smith and terry fonton will make a lot of money to make some very difficult choices I think they do it unbiased and I think that's a positive Marcus could come out of the buy And play like play like crazy knowing that if you want to be a starter in the future The next four games will determine that maybe the falcons went off four with marcus and everything's great Maybe they go on four with marcus. Maybe they go on four with ridder. There's a there's a bunch of different possibilities here There are zero guarantees with any of it. You're just at a point of desperation Where you really have to evaluate what's the best for us? We're kind of getting knocked around a little bit What's our best shot at taking advantage of this of this unique opportunity? Um, can we just There's some things in the script about talking about this game. Let's forego them. Okay Does anybody else have anything to say about the quarterback before we go big picture nfc south One thing that I will add and this is something that actually came up in the middle of the week this past week where arthur smith was talking about the The part of the game That is the most difficult for players to like un truly understand unless they're in it He was talking about from college to the pros the biggest difference is in the pocket And how everything is maneuvered how you see defenses how quickly Defenders get into the pocket and into the backfield I think it's very interesting that that point came up this past week and i'm not saying that. Oh, that was arthur smith like sprinkling a little foreshadowing then that's not what i'm saying at all because it was just the way the conversation went But I do think it's fascinating that as we're talking about potentially Seeing desmond ritter just knowing that arthur smith says one of the hardest adjustments For any young player to make is actually being in a live nfl pocket And how different it is from the college game And so I just wanted to leave that note in there too because I found it kind of interesting that that came up this This week Yeah, and I think the reason why the the quarterback thing is such a hot button issue is because the falcons are still sort of Kind of totally realistically in it for the division crown if they were playing the other division except for the nfc south They would be at least Three games back with four games to play. That's essentially elimination, right? Yeah At least three back in the every other division that there is they are not in contention for the wildcard at this point They are the 11 seed in the nfc. That's way farther down and with with seven total positions three wildcards So that's not a possibility arthur smith. I think on wednesday called it a quote-unquote unique End quote opportunity that they have in front of them It's something that has more to do with what tampa bay has done than what the falcons have done lately The box just kind of keep them in it And I brought this up or tory brought it up when I was writing my column and we brought up in this podcast And all of a sudden the saints are sort of feeling like They were completely down and out and if they beat tampa and then they go rest up and then they beat the falcons They feel good about themselves too. So anyway, they're still in it Now we have a bi week for the falcons to try to figure out where they're going if I am Correct arthur smith was quoted as saying changes will be made. Does that sound correct? Yes, and yeah, no he he did say that and I will say that I know That in twitter verse that that quote will be taken out of context And it will be focused mainly on the quarterback situation that we previously talked about But the context of that quote was arthur smith saying that there will be changes made to the team Not to just the quarterback to the team as a whole. So I want to make sure that the context is there Yeah, as soon as you head into this bi week and you absorb everything you've seen over the last 13, right? Where do you think and if the answer is quarterback to the answer somewhere else? It doesn't matter But where do you think that that that a change could help the falcons in what areas do you think that they're deficient with personnel to get better?  So I know they're being the I already know that but I do think on both sides of the ball You know, if there's major changes that could be made we saw today against the stillers The falcons defense gave up too many first downs And I think the stillers first job was like seven minutes and 27 seconds They had it for 16 plays that wore down the defense And I think that's something the defense can't allow teams to do As we get later in the season and especially as we get into the playoffs, that's extremely important. Um, You know that eats away at the clock and that limits the time that the offense has on the field So I do think the defense has to be more efficient When stopping teams like the stillers were, you know, they would run for nine yards It'll it'll be a third and one and then they will get that extra one yard to continue to move the chains And I think, you know, those little things is something that the the falcons defense really has to hone in on is Really limiting that chunk yardage. Um, I think on the offensive end what we saw today from the rushing attack You know, we saw them come alive really late in the third quarter But the offense they were too slow in the first two quarters And that's something, you know, when the offense starts out slow Usually the game doesn't go well and I and I think Like players I mentioned all season you have to start fast early in the first quarter To have any any fishing game and I think, um, you know, with some players Potentially coming back from uh, injured reserve. I think that could help. Um, but again I think the falcons have to start fast and especially going into these last four games, you know They just have to be more efficient on both sides on both sides of the ball Yeah, I mean it it's one of those things where I think you could look at that outside cornerback spot and wonder Could we put somebody in other than Darren Hall that might give you better is more of troy anderson and maybe less of michael walker could that Help you out. Could they redefine some roles within the sub packages is lorenzo carter doing enough Does de angelo malone need more? I think more opportunities I don't think again, whether we're talking about the quarterback or any of these changes that I just kind of like haphazardly throughout there I'm not suggesting that any of those be made But again, none of these changes with this roster as it's currently constructed with its injury issues as ashen pointed out There's no guarantee that uh, you swap Rashad fenton who is inactive today. I'm just using his name for Darren Hall or You know, or you give d alpha to shot on the outside I don't know something like that that it's that it's going to be like a miracle cure I don't think there is one necessarily with the options that they have they just need to get discernibly better In several different areas and why not try something because when you lose four of five That really kind of sends you into An issue right four or five and you're still in it. What do you do? What can you do? To make a change there Yeah, and I also think it is important To that some of the pieces that I think Atlanta will have available to them in two weeks time could potentially You know Arthur Smith is talking about the changes and stuff But I think potentially getting Elijah Wilkinson back would be really a really really good thing for this offensive line Not that I'm saying that I think the offensive line is playing poorly. I don't really think that at all Um sit in his absence. I think they've had moments where they haven't played well, but not Full games where this offensive line has not played well um The only time I can really think of is Carolina at Carolina and I think they did a good job of evaluating that moving forward I think there's a potential that you could get arnold abacadie back ak was has been This forearm injury of his has been lingering for a couple of weeks now I think it was actually a very conservative approach that the falcons took Against the Steelers to rest ak in hopes of maybe Resting him this week resting him again for a bi week having a full week of prep for the saints I think it'd be good to have ak back because I really do think that ak was on an upward trend before he got hurt Now you get some of these guys back But what do you do in other spots and and what moves do you make the fact that arthur smith has said Changes are coming. We are going to change things. What does that realistically look like? You know, you do not have cow pits for the remainder of the season How how does that change continue to change what this offense does with its weapons? I think all of these things are just All offshoots of the same question in that how do the falcons Win games they have to start winning games. They I feel like the slide they have been on Since probably even before the carolina loss has been really really significant for this team And it's why they are in the spot. They're in right now So how do you write the ship knowing how important these next slate of games are to any potential future that you have after the regular season ends Yeah, and we've talked a lot about the possibility of you know, maybe the saints and falcons being even with tampa bay after their bi weeks They could also the falcons could also be too back with four to play and right less tampa could win to this They still have tom radion mike evans and Bit of veya and a thousand other amazing players Will they turn on the switch? So it is one of those moments where you need to Objectively look at it and see where can we get 1% better right because these games are so close Yeah That that 1% that that extra play that extra yard or first down or third down prevention or third down conversion can turn A tide here and I think that all those things are important. I mean other falcons reeling and panicking I don't think so Arthur Smith is very good at being objective. He's also Very willing to say This isn't going well for us. This isn't going well for us as play callers or as Executors of plays how they emerge from this bi week the decisions that they make without again any guarantees of success with any of them It's going to be important This bi week is about rest and trying to relax and trying to re-center and refocus But I think the news and decisions that come out of it Will be pivotal as the falcons try to make that push try to turn the tide try to do something Maybe that they don't deserve and that is go out and win a division title because it's there for you And they're not giving it back Right, so how they look at that is going to be important We love to hear of course what you guys think about this whole thing You've got a mail back and you've got a you know youtube comments on like on this thing What changes would you make of course? We all know what we want Great review subscribe to the Atlanta falcons podcast network You get one stop shopping for falcons focus falcons audible and of course the falcons final whistle Thank you all so much for downloading and listening And yeah, maybe like get outside on sunday. I don't know just a thought Next week and enjoy it All right guys, we will come to you after the buy After a game in new Orleans against the saints that no matter what happens over the over monday and then the next week is going to be pretty big


Studying Romeo and Juliet? Let's look at the exchange between Romeo and Juliet when they first meet. Romeo uses oxymorons when he talks about the Holy Shrine in Gentle Sin, and this oxymoron shows that he sees talking to Juliet almost as a religious experience. The words holy, sin and pilgrims belong to the semantic field of religion, again showing that he feels almost seeing Juliet as a religious experience. Juliet echoes Romeo's words but also using religious language, pilgrim, devotion, and this ties into what the chorus at the beginning of the story said. They stated that it's almost God's will, it's written in the stars that they meet. Juliet tells Romeo saints have hands, in other words she's saying you're flattering me too much by telling me that I'm almost a saint. The repetition of the word poem also shows that she has fallen for him. Romeo asks this poetic question as a way of hinting that he wants to kiss Juliet. This is Eurya and Juliet's response is interesting because it shows she's not shy or coy, she's actually encouraging Romeo to make his first move.


Olga box clips are some enigmas better than others of course so there's several things that can do with that we have some filters for that so if you go into it now i i tend to have them all off because i like to have all the features and or i like to have all of the opportunities and let myself choose but if you don't trust yourself you can turn on mac vu filtering you can do color coded signals and you can turn on the speed let me show you what that looks like you guys are choosing a font type one called impact and store it out quite nicely easy to see and easy to read about 30 picks font is a good one so now you can start to see the speed so this one at you see how that you might think oh that's a 400 that must be good actually it's not 400 that's the speed that means that the market's going so maybe not 400 easy filter 400 filter filter that's way too fast to speed you want something in the you know less than 100 really you want something in the neighborhood between on well down here on the ones and twos you can go up to 150 but you don't want to really be beyond 150 at 190 196 getting screwed one yeah perfect speed and then direction so direction of the color so yellow is neutral red is obviously short pink is strong strong short and those are color coded with our strong sell mac vu with the direction of multiple markets simultaneously now sometimes you just want to wait for the markets to get moving like right now so i like that the market's on the move although it's way too fast it's at 500 and something right now so i would go up right so how do i slow down this market everybody tell me i'm on the alga bar ones how do i slow you know air quotes i'm saying air quotes here how do i slow down this market for me to play i'll go to very good so i can shift down i'll switch to twos what's the speed here 280 oh still too fast still too fast what should i do let's go to alga bar threes right okay i'm shifting to a three press the like button share subscribe and comment below with your thoughts and what you'd learn watch this next video


Hey everyone, welcome back for more ExoZero's content, today's video we're going to discuss two more light heroes that have been teased by ExoZero's, they will drop in future updates. But before that, if you wanna see more ExoZero's content, please hit the subscribe button down below. So the story starts by us discovering this in the Colosseum. So a lot of players already have discussed this in discord, in their communities. So just to at least discuss this, so at least you have more or less a full view of what Schmidt can do and also Seowa. So we'll start with Schmidt. So Schmidt is a super elite treasure hunter. So Schmidt is the general for Vagabond Nation. So to start with him, so we'll go through his passive. So he has a passive, counter three. So counters upon taking damage gain one mana. If target dies, gain mana of health if it is at 70% or more. So that's the usual counter three. Then we go next to flow mana, so overtime effect. So he grants mana to the back row allies permanently for one mana again. This is his rare, sorry, his unique passive. It's called master's footsteps. So grants master's footsteps to allies with lower defense than the caster. So again, for him, he has to have the highest defense stack of all the heroes in the team. So his other passive is prey, afflicts the prey mark when the skill hits. Grants turn reset for allies possessing master's footsteps when the ally attacks with an enemy marked by prey. So when Schmidt attacks, he gives the enemy the prey mark that automatically his allies, which has master's footsteps, will have a turn reset when attacking the enemy. So this is basically a nice skill to have because it gives them at least another attack for their basic attack. So the last would be gargantuan, so reduces own receive damage by 90% when all allies with master's footsteps effect survives. So if all of his allies survive, he reduces damage by 90%, which is a big reduction. So this is actually, I think, a god tier passive. So I'm not sure if this passive will be retained once they will be released or once they will be launched in a certain update, but this is actually at par with the other generals that we have on our roster. So for his skills, so S1 is gravestorm sword, so deals 178 damage to all enemies. So mana cost 3, and S2 is a grandmaster cross, deals 1050% damage to one enemy, mana 5, and also is a burst skill. So if you can remember my other video with Xeon, I'll post a link above here. My assessment for Xeon, as well as Schmidt, they will be good in PvP. So this actually, this whole package of Schmidt compliments Xeon already. They will be, I'm not sure if they're going to carve a niche in the meta. By the way guys, just a friendly reminder, please do subscribe to my channel. A few percentage of about 10 to 15% of my views come from my subscribers. So please do support my channel. So here we are at Seowa, so she's called an innocent lady, so I'm not sure why. But her passive is first aid 3, so grants heal of 100% of attack to an ally if they take damage and their health drops under 20%. So gain 1 mana if the caster's health is at 20% or less when triggered, and gain mana if the caster's health is at 70% or less when triggered. So again, your regular first aid. Her next passive is spring wind, when effected by master's footsteps, so take note this is the unique passive of Schmidt. The caster grants an effect that increases nullify heal immunity and health, health regenerating by 100% to all allies who are also affected by master's footsteps. So just to shorten this one, your team will be immune to nullify heal. Ramji has this one for nullify heal, so he gives nullify heal to the enemy team. So you'll be immune to that. This is actually good as well in terms of PVP, and we move on to his skills. So for his S1, it's sky butterfly, heals all allies by 34% of own maximum health, cleanses all debuff, and damage over time effects from allies. So it's a mana 3 skill, and this is a burst skill for a heal skill. Her S2 is wind dance, so deals 255% damage to all enemies, and mana is 4. So for Seo, I think she's a bit okay. She is a bit all around. Her skills can be good in PVP and PvE contents. And she's built as a support unit, nothing special. The only special passive was spring wind so that she can protect the whole team from nullify heal. That's it for me guys, let me know in the comments below what your thoughts are on these new light heroes that are going to be released, they're not released yet. So I'm not sure also that they will retain all of their skills once they are released. So anyway, y'all stay safe, and I'll see you in the next video, warden out.