question stringlengths 6 3.53k | text stringlengths 17 2.05k | source stringclasses 1
value |
|---|---|---|
Consider the following contains function defined on Iterable (in particular, it accepts both Vector and List). def contains[A](l: Iterable[A], elem: A): Boolean = val n = l.size if n <= 5 then for i <- l do if i == elem then return true false else val (p0, p1) = parallel( contains... | This can happen for at most 2K(x,y)-l = 2k different strings. These strings can be enumerated given k,l and hence x can be specified by its index in this enumeration. The corresponding program for x has size k + O(1). Theorem proved. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following contains function defined on Iterable (in particular, it accepts both Vector and List). def contains[A](l: Iterable[A], elem: A): Boolean = val n = l.size if n <= 5 then for i <- l do if i == elem then return true false else val (p0, p1) = parallel( contains... | The earliest result may be found directly from elementary probability theory. Suppose we model the above process taking L {\displaystyle L} and G {\displaystyle G} as the fragment length and target length, respectively. The probability of "covering" any given location on the target with one particular fragment is then ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the asymptotic work of <code>parGroupyBy2</code>? | {\displaystyle {\begin{aligned}\mathbb {A} :\ \sum _{i\in \mathbb {A} }2^{i}&=n-k,\\\mathbb {B} :\ \sum _{j\in \mathbb {B} }2^{j}&=\left\lfloor {\dfrac {k-1}{2}}\right\rfloor .\\\end{aligned}}} One can mimic a bitwise AND operation by intersecting these two sets: { n k } mod 2 = { 0 , A ∩ B ≠ ∅ ; 1 , A ∩ B = ∅ ; {\disp... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the asymptotic work of <code>parGroupyBy2</code>? | Asymptotically, this probability is λ {\displaystyle \lambda } . More precisely, λ = lim n → ∞ Prob { P 2 ( n ) ≤ P 1 ( n ) } {\displaystyle \lambda =\lim _{n\to \infty }{\text{Prob}}\left\{P_{2}(n)\leq {\sqrt {P_{1}(n)}}\right\}} where P 2 ( n ) {\displaystyle P_{2}(n)} is the second largest prime factor n. The Golomb... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2,y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. Define a case class Rectangle storing ... | In the case of d = 2 {\displaystyle d=2} the rectangle is represented by ( ( x m i n , y m i n ) , ( x m a x , y m a x ) ) {\displaystyle \,((x_{min},y_{min}),(x_{max},y_{max}))} and the MBR thus four corners ( x m i n , y m i n , x m a x , y m a x ) {\displaystyle \,(x_{min},y_{min},x_{max},y_{max})} . | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2,y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. Define a case class Rectangle storing ... | Dominating rectangles, or box representation, maps the points on the lower of the two lines of the trapezoid representation as lying on the x-axis and that of the upper line as lying on the y-axis of the Euclidean plane. Each trapezoid then corresponds to an axis-parallel box in the plane. Using the notion of a dominan... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following scheduler policies are preemptive? | The scheduler will delay preemption as long as possible if there are unused logical CPUs. If a task is marked idle priority policy, it cannot preempt at all even other idle policy marked tasks but rather use cooperative multitasking. : ln 2341–2344 | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following scheduler policies are preemptive? | Fixed-priority preemptive scheduling is a scheduling system commonly used in real-time systems. With fixed priority preemptive scheduling, the scheduler ensures that at any given time, the processor executes the highest priority task of all those tasks that are currently ready to execute. The preemptive scheduler has a... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following are correct implementation for acquire function ? Assume 0 means UNLOCKED and 1 means LOCKED. Initially l->locked = 0. | The first blocked lock for operation in the queue is acquired as soon as the existing blocking lock is removed from the object, and then its respective operation is executed. If a lock for operation in the queue is not blocked by any existing lock (existence of multiple compatible locks on a same object is possible con... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following are correct implementation for acquire function ? Assume 0 means UNLOCKED and 1 means LOCKED. Initially l->locked = 0. | So when P1 tries to acquire the lock it immediately succeeds and next_ticket is incremented to 1 (Row 2). When P3 tries to acquire the lock it gets 1 for its my_ticket, next ticket is incremented to 2, and it must wait since now_serving is still 0 (Row 3). Next, when P2 attempts to acquire the lock it gets 2 for its my... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Aggregate functions present a bottleneck, because they potentially require having all input values at once. In distributed computing, it is desirable to divide such computations into smaller pieces, and distribute the work, usually computing in parallel, via a divide and conquer algorithm. Some aggregate functions can ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Many parallel databases use distributed parallel processing to execute the queries. While executing an aggregate function such as sum, the following strategy is used: Compute a partial sum locally and concurrently at each processor using the data present in the associated disk partition with it. Add these local subtota... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Freshly graduated from EPFL, you have been hired as contractors for a successful and rapidly growing bank. The bank has been experiencing problems with their money management system recently, which is written in Scala, and so they hired the best and brightest young engineer they could find: you! The system had been wor... | One of lock-based programming's biggest problems is that "locks don't compose": it is hard to combine small, correct lock-based modules into equally correct larger programs without modifying the modules or at least knowing about their internals. Simon Peyton Jones (an advocate of software transactional memory) gives th... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Freshly graduated from EPFL, you have been hired as contractors for a successful and rapidly growing bank. The bank has been experiencing problems with their money management system recently, which is written in Scala, and so they hired the best and brightest young engineer they could find: you! The system had been wor... | Consider a banking application as an example, and a transaction in it—the transfer function, which takes money from one account, and puts it into another account. In the IO monad, this might look like: This causes problems in concurrent situations where multiple transfers might be taking place on the same account at th... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In which of the following cases does JOS acquire the big kernel lock? | In operating systems, a giant lock, also known as a big-lock or kernel-lock, is a lock that may be used in the kernel to provide concurrency control required by symmetric multiprocessing (SMP) systems. A giant lock is a solitary global lock that is held whenever a thread enters kernel space and released when the thread... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In which of the following cases does JOS acquire the big kernel lock? | The Linux kernel had a big kernel lock (BKL) since the introduction of SMP, until Arnd Bergmann removed it in 2011 in kernel version 2.6.39, with the remaining uses of the big lock removed or replaced by finer-grained locking. Linux distributions at or above CentOS 7, Debian 7 (Wheezy) and Ubuntu 11.10 are therefore no... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
There are N philosphers sitting around a circular table eating spaghetti and discussing philosphy. The problem is that each philosopher needs two forks to eat, and there are only $N$ forks, one between each pair of philosophers. We want to design an algorithm that the philosophers can use, that ensures that no one star... | Each philosopher can only alternately think and eat. Moreover, a philosopher can only eat their spaghetti when they have both a left and right fork. Thus two forks will only be available when their two nearest neighbors are thinking, not eating. After an individual philosopher finishes eating, they will put down both f... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
There are N philosphers sitting around a circular table eating spaghetti and discussing philosphy. The problem is that each philosopher needs two forks to eat, and there are only $N$ forks, one between each pair of philosophers. We want to design an algorithm that the philosophers can use, that ensures that no one star... | A solution presented by William Stallings is to allow a maximum of n-1 philosophers to sit down at any time. The last philosopher would have to wait (for example, using a semaphore) for someone to finish dining before they "sit down" and request access to any fork. This guarantees at least one philosopher may always ac... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In an x86 multiprocessor with JOS, how many Bootstrap Processors (BSP) is it possible to have at most? And how many Application Processors (AP) at most? | A symmetric multiprocessor (SMP) is a computer system with multiple identical processors that share memory and connect via a bus. Bus contention prevents bus architectures from scaling. As a result, SMPs generally do not comprise more than 32 processors. Because of the small size of the processors and the significant r... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In an x86 multiprocessor with JOS, how many Bootstrap Processors (BSP) is it possible to have at most? And how many Application Processors (AP) at most? | Symmetric multiprocessing or shared-memory multiprocessing (SMP) involves a multiprocessor computer hardware and software architecture where two or more identical processors are connected to a single, shared main memory, have full access to all input and output devices, and are controlled by a single operating system i... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Under which condition(s) on z,... | For the algorithm to be correct, all steps that identify n must be correct. Steps 1, 3 and 4 are trivially correct, since they are based on direct tests of the divisibility of n. Step 5 is also correct: since (2) is true for any choice of a coprime to n and r if n is prime, an inequality means that n must be composite.... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Under which condition(s) on z,... | Therefore, fg is also in M(S, G), i.e. M(S, G) is closed. M(S, G) is associative because ((fg)h)(x) = (fg)(x)h(x) = (f(x)g(x))h(x) = f(x)(g(x)h(x)) = f(x)(gh)(x) = (f(gh))(x). And there is a map i such that i(x) = e where e is the identity element of G. The map i is such that for all f in M(S, G) we have fi = if = f, i... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2, y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. Define a function hull that, given an... | For a finite set of points in the plane the lower bound on the computational complexity of finding the convex hull represented as a convex polygon is easily shown to be the same as for sorting using the following reduction. For the set x 1 , … , x n {\displaystyle x_{1},\dots ,x_{n}} numbers to sort consider the set ( ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2, y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. Define a function hull that, given an... | Let C be a set of n axis-parallel rectangles in the plane. The following algorithm finds a disjoint set with a size of at least | M D S ( C ) | log n {\displaystyle {\frac {|MDS(C)|}{\log {n}}}} in time O ( n log n ) {\displaystyle O(n\log {n})}: INITIALIZATION: sort the horizontal edges of the given rectangles by ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Aggregate functions present a bottleneck, because they potentially require having all input values at once. In distributed computing, it is desirable to divide such computations into smaller pieces, and distribute the work, usually computing in parallel, via a divide and conquer algorithm. Some aggregate functions can ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Many parallel databases use distributed parallel processing to execute the queries. While executing an aggregate function such as sum, the following strategy is used: Compute a partial sum locally and concurrently at each processor using the data present in the associated disk partition with it. Add these local subtota... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Assume a user program executes following tasks. Select all options that will use a system call. | There are two techniques by which a program executing in user mode can request the kernel's services: System call Message passingOperating systems are designed with one or the other of these two facilities, but not both. First, assume that a user process wishes to invoke a particular target system function. For the sys... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Assume a user program executes following tasks. Select all options that will use a system call. | In computing, a system call (commonly abbreviated to syscall) is the programmatic way in which a computer program requests a service from the operating system on which it is executed. This may include hardware-related services (for example, accessing a hard disk drive or accessing the device's camera), creation and exe... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the content of the inode? | The inodes area. Each file or directory is represented as an inode, which records metadata including type (file, directory, block, char, pipe), IDs for user and group, three timestamps that record the date and time of last access, last modification and last status change. An inode also contains a list of addresses that... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the content of the inode? | LED is located in diode section. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In x86, what are the possible ways to transfer arguments when invoking a system call? For example, in the following code, string and len are sys_cputs’s arguments. | Some arguments can contain megabytes of data, all of which must be copied and transmitted to the receiving object. Traditional procedure calls differ from message-passing in terms of memory usage, transfer time and locality. Arguments are passed to the receiver typically by general purpose registers requiring no additi... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In x86, what are the possible ways to transfer arguments when invoking a system call? For example, in the following code, string and len are sys_cputs’s arguments. | Modern x86 operating systems are transitioning away from CALL FAR call gates. With the introduction of x86 instructions for system call (SYSENTER/SYSEXIT by Intel and SYSCALL/SYSRET by AMD), a new faster mechanism was introduced for control transfers for x86 programs. As most other architectures do not support call gat... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the worst case complexity of listing files in a directory? The file system implements directories as hash-tables. | Each position in this table corresponds to a specific directory entry record. The hash table, being one sector in length, can index a maximum of 256 directory records or files. The directory itself is sized according to disk capacity by being a maximum of one cylinder (up to 34 sectors). | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the worst case complexity of listing files in a directory? The file system implements directories as hash-tables. | When a file is to be opened for access, the system needs to search the directory for its directory record. Search time is minimized by using a hashing technique to reduce the 11-character string formed from the file name and extension to a one byte value. The hash code for each file is stored in a Hash Index Table (HIT... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Implement aggregate using the... | Thus for any list homomorphism h, there exists a parallel implementation. That implementation cuts the list into chunks, which are assigned to different computers; each computes the result on its own chunk. It is those results that transit on the network and are finally combined into one. In any application where the l... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Implement aggregate using the... | Many parallel databases use distributed parallel processing to execute the queries. While executing an aggregate function such as sum, the following strategy is used: Compute a partial sum locally and concurrently at each processor using the data present in the associated disk partition with it. Add these local subtota... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider an operation we will call scanRight1 that, given a function $f$ of two arguments, and a sequence $a_1, \ldots, a_N$, computes a sequence $b_1, \ldots, b_N$ such that: $b_N = a_N$ $b_i = f(a_{i}, b_{i+1})$, for $0 < i < N$ Define similarly scanLeft1 in a manner similar to scanRight1: Given a function $f$ of t... | Given two sets A , B ⊆ N {\displaystyle A,B\subseteq \mathbb {N} } of natural numbers, we say A {\displaystyle A} is Turing reducible to B {\displaystyle B} and write A ≤ T B {\displaystyle A\leq _{T}B} if and only if there is an oracle machine that computes the characteristic function of A when run with oracle B. In t... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider an operation we will call scanRight1 that, given a function $f$ of two arguments, and a sequence $a_1, \ldots, a_N$, computes a sequence $b_1, \ldots, b_N$ such that: $b_N = a_N$ $b_i = f(a_{i}, b_{i+1})$, for $0 < i < N$ Define similarly scanLeft1 in a manner similar to scanRight1: Given a function $f$ of t... | In functional programming terms, the prefix sum may be generalized to any binary operation (not just the addition operation); the higher order function resulting from this generalization is called a scan, and it is closely related to the fold operation. Both the scan and the fold operations apply the given binary opera... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
As a group, write a function called minMax, which should take a non-empty array as input and return a pair containing the smallest and the largest element of the array. def minMax(a: Array[Int]): (Int, Int) = ??? Now write a parallel version of the function. You may use the constructs task and/or parallel, as seen in ... | For the variant of the problem which disallows empty subarrays, best_sum should be initialized to negative infinity instead and also in the for loop current_sum should be updated as max(x, current_sum + x). In that case, if the input contains no positive element, the returned value is that of the largest element (i.e.,... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
As a group, write a function called minMax, which should take a non-empty array as input and return a pair containing the smallest and the largest element of the array. def minMax(a: Array[Int]): (Int, Int) = ??? Now write a parallel version of the function. You may use the constructs task and/or parallel, as seen in ... | The following pseudocode rearranges the elements between left and right, such that for some value k, where left ≤ k ≤ right, the kth element in the list will contain the (k − left + 1)th smallest value, with the ith element being less than or equal to the kth for all left ≤ i ≤ k and the jth element being larger or equ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Aggregate functions present a bottleneck, because they potentially require having all input values at once. In distributed computing, it is desirable to divide such computations into smaller pieces, and distribute the work, usually computing in parallel, via a divide and conquer algorithm. Some aggregate functions can ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Many parallel databases use distributed parallel processing to execute the queries. While executing an aggregate function such as sum, the following strategy is used: Compute a partial sum locally and concurrently at each processor using the data present in the associated disk partition with it. Add these local subtota... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Aggregate functions present a bottleneck, because they potentially require having all input values at once. In distributed computing, it is desirable to divide such computations into smaller pieces, and distribute the work, usually computing in parallel, via a divide and conquer algorithm. Some aggregate functions can ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Consider the parallel sequence... | Many parallel databases use distributed parallel processing to execute the queries. While executing an aggregate function such as sum, the following strategy is used: Compute a partial sum locally and concurrently at each processor using the data present in the associated disk partition with it. Add these local subtota... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Imagine that the data structure you are given, instead of an Array[A], is one called ParSeq[A]. This class offers the two following methods, which work in parallel: def map[B](f: A => B): ParSeq[B] def reduce(f: (A, A) => A): A Can you write the following minMax function in terms of map and/or reduce operations ? def... | Thus for any list homomorphism h, there exists a parallel implementation. That implementation cuts the list into chunks, which are assigned to different computers; each computes the result on its own chunk. It is those results that transit on the network and are finally combined into one. In any application where the l... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Imagine that the data structure you are given, instead of an Array[A], is one called ParSeq[A]. This class offers the two following methods, which work in parallel: def map[B](f: A => B): ParSeq[B] def reduce(f: (A, A) => A): A Can you write the following minMax function in terms of map and/or reduce operations ? def... | To increase efficiency, a number of data sets have this operation applied to them simultaneously, before the data is structured together again at the end. ‘Forks’ are similar to ‘maps’ but they use a different operation for certain data types. This is known as multiple data parallelism. ‘Reduces’ or ‘scans’ are used to... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In JOS, suppose one Env sends a page to another Env. Is the page copied? | Post-copy sends each page exactly once over the network whereas pre-copy can transfer the same page multiple times if the page is dirtied repeatedly at the source during migration. On the other hand, pre-copy retains an up-to-date state of the VM at the source during migration, whereas during post-copy, the VM's state ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In JOS, suppose one Env sends a page to another Env. Is the page copied? | The child borrows the memory management unit setup from the parent and memory pages are shared among the parent and child process with no copying done, and in particular with no copy-on-write semantics; hence, if the child process makes a modification in any of the shared pages, no new page will be created and the modi... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In JOS and x86, please select all valid options for a system call. | select is a system call and application programming interface (API) in Unix-like and POSIX-compliant operating systems for examining the status of file descriptors of open input/output channels. The select system call is similar to the poll facility introduced in UNIX System V and later operating systems. However, with... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In JOS and x86, please select all valid options for a system call. | Most work in the monolithic kernel is done via system calls. These are interfaces, usually kept in a tabular structure, that access some subsystem within the kernel such as disk operations. Essentially calls are made within programs and a checked copy of the request is passed through the system call. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Concatenating two conc-trees of heights $h_1$ and $h_2$ yields a conc-tree with
height $h$ where | An H tree can be constructed by starting with a line segment of arbitrary length, drawing two shorter segments at right angles to the first through its endpoints, and continuing in the same vein, reducing (dividing) the length of the line segments drawn at each stage by 2 {\displaystyle {\sqrt {2}}} . A variant of this... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Concatenating two conc-trees of heights $h_1$ and $h_2$ yields a conc-tree with
height $h$ where | There are bijective correspondences between recursive trees of size n and permutations of size n − 1. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What are the drawbacks of non-preemptive scheduling compared to preemptive scheduling? | The no preemption condition may also be difficult or impossible to avoid as a process has to be able to have a resource for a certain amount of time, or the processing outcome may be inconsistent or thrashing may occur. However, the inability to enforce preemption may interfere with a priority algorithm. Preemption of ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What are the drawbacks of non-preemptive scheduling compared to preemptive scheduling? | However this low-level scheduling has its drawbacks. A process that seldom needs to interact with peripherals or other processes would simply hog processor resource until it completed or was halted by manual intervention. The result, particularly for interactive systems running tasks that frequently interact with the o... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select valid answers about file descriptors (FD): | In Unix and Unix-like computer operating systems, a file descriptor (FD, less frequently fildes) is a process-unique identifier (handle) for a file or other input/output resource, such as a pipe or network socket. File descriptors typically have non-negative integer values, with negative values being reserved to indica... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select valid answers about file descriptors (FD): | Now suppose that the user program successfully executes the following statement: The variable fd now contains the index of a file descriptor in the process's file descriptor table. This file descriptor is a capability. Its existence in the process's file descriptor table is sufficient to show that the process does inde... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the default block size for a traditional file system, e.g. ext3/4? | Because file size references are stored in eight instead of four bytes, the file size limit has increased to 16 exabytes (EB) (264 − 1 bytes, or about 1019 bytes, which is otherwise limited by a maximum volume size of 128 PB, or 257 − 1 bytes), raised from 4 GB (232 − 1 bytes) in a standard FAT32 file system. Therefore... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the default block size for a traditional file system, e.g. ext3/4? | File systems have traditionally divided the disk into equally sized blocks to simplify their design and limit the worst-case fragmentation. Block sizes are typically multiples of 512 bytes due to the size of hard disk sectors. When files are allocated by some traditional file systems, only whole blocks can be allocated... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Suppose a file system used only for reading immutable files in random fashion. What is the best block allocation strategy? | In some scenarios where the majority of files are shorter than half the block size, such as in a folder of small source code files or small bitmap images, tail packing can increase storage efficiency even more than twofold, compared to file systems without tail packing.This not only translates into conservation of disk... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Suppose a file system used only for reading immutable files in random fashion. What is the best block allocation strategy? | Deciding from benchmarking results, when used with relatively small number of servers (15), the file system achieves reading performance comparable to that of a single disk (80–100 MB/s), but has a reduced write performance (30 MB/s), and is relatively slow (5 MB/s) in appending data to existing files. The authors pres... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following contains function defined on Iterable (in particular, it accepts both Vector and List). def contains[A](l: Iterable[A], elem: A): Boolean = val n = l.size if n <= 5 then for i <- l do if i == elem then return true false else val (p0, p1) = parallel( contains... | Suppose the set of vertices of K is given as an input, so that K = conv ( v 1 , … , v k ) = {\displaystyle K={\text{conv}}(v_{1},\ldots ,v_{k})=} the convex hull of its vertices. Then, deciding whether y is in K requires to check whether y is a convex combination of the input vectors, that is, whether there exist coeff... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following contains function defined on Iterable (in particular, it accepts both Vector and List). def contains[A](l: Iterable[A], elem: A): Boolean = val n = l.size if n <= 5 then for i <- l do if i == elem then return true false else val (p0, p1) = parallel( contains... | This can happen for at most 2K(x,y)-l = 2k different strings. These strings can be enumerated given k,l and hence x can be specified by its index in this enumeration. The corresponding program for x has size k + O(1). Theorem proved. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following contains function defined on Iterable (in particular, it accepts both Vector and List). def contains[A](l: Iterable[A], elem: A): Boolean = val n = l.size if n <= 5 then for i <- l do if i == elem then return true false else val (p0, p1) = parallel( contains... | It will first check if the element is at the middle of the vector. If not, then it will check if the middle element is greater or lesser than the sought element. At this point, half of the vector can be discarded, and the algorithm can be run again on the other half. The number of comparisons will be given by c 1 = 1 {... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider the following contains function defined on Iterable (in particular, it accepts both Vector and List). def contains[A](l: Iterable[A], elem: A): Boolean = val n = l.size if n <= 5 then for i <- l do if i == elem then return true false else val (p0, p1) = parallel( contains... | An exact cover problem is defined by the binary relation "contains" between subsets in S and elements in X. There are different equivalent ways to represent this relation. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following operations would switch the user program from user space to kernel space? | Kernel space can be accessed by user-mode only through the use of system calls. End user programs like the UNIX shell or other GUI-based applications are part of user space. These applications interact with hardware through kernel supported functions. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which of the following operations would switch the user program from user space to kernel space? | The term user space (or userland) refers to all code that runs outside the operating system's kernel. User space usually refers to the various programs and libraries that the operating system uses to interact with the kernel: software that performs input/output, manipulates file system objects, application software, et... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2,y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. How can the result be computed in para... | In computational geometry, a number of algorithms are known for computing the convex hull for a finite set of points and for other geometric objects. Computing the convex hull means constructing an unambiguous, efficient representation of the required convex shape. Output representations that have been considered for c... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2,y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. How can the result be computed in para... | Let C be a set of n axis-parallel rectangles in the plane, all with the same height but with varying lengths. There is an algorithm that finds a disjoint set with a size of at least |MDS(C)|/(1 + 1/k) in time O(n2k−1), for every constant k > 1.The algorithm is an improvement of the above-mentioned 2-approximation, by c... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider an operation we will call scanRight1 that, given a function $f$ of two arguments, and a sequence $a_1, \ldots, a_N$, computes a sequence $b_1, \ldots, b_N$ such that: $b_N = a_N$ $b_i = f(a_{i}, b_{i+1})$, for $0 < i < N$ Define similarly scanLeft1 in a manner similar to scanRight1: Given a function $f$ of tw... | Given two sets A , B ⊆ N {\displaystyle A,B\subseteq \mathbb {N} } of natural numbers, we say A {\displaystyle A} is Turing reducible to B {\displaystyle B} and write A ≤ T B {\displaystyle A\leq _{T}B} if and only if there is an oracle machine that computes the characteristic function of A when run with oracle B. In t... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider an operation we will call scanRight1 that, given a function $f$ of two arguments, and a sequence $a_1, \ldots, a_N$, computes a sequence $b_1, \ldots, b_N$ such that: $b_N = a_N$ $b_i = f(a_{i}, b_{i+1})$, for $0 < i < N$ Define similarly scanLeft1 in a manner similar to scanRight1: Given a function $f$ of tw... | In functional programming terms, the prefix sum may be generalized to any binary operation (not just the addition operation); the higher order function resulting from this generalization is called a scan, and it is closely related to the fold operation. Both the scan and the fold operations apply the given binary opera... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the complexity of concatenation of two conc-trees with heights $h_1$ and
$h_2$? | Thus the group G exhibits a large gap between the growth of its Dehn function and the complexity of its word problem. The conjugacy problem in G is known to be decidable, but the only known worst-case upper bound estimate for the complexity of the conjugacy problem, due to Janis Beese, is elementary recursive. It is co... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the complexity of concatenation of two conc-trees with heights $h_1$ and
$h_2$? | There are bijective correspondences between recursive trees of size n and permutations of size n − 1. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What property does the function f passed to reduce need to satisfy in order to have the same result regardless on how reduce groups the applications of the operation f to the elements of the data structure? Prove that your function f indeed satisfies that property. | Let P1 and P2 be two problems in FNP, with associated verification algorithms A1, A2. A reduction P1 and P2 is defined as two efficiently-computable functions, f and g, such that f maps inputs x to P1 to inputs f(x) to P2 ; g maps outputs y to P2 to outputs g(y) to P1 ; For all x and y: if A2(f(x),y) returns true, then... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What property does the function f passed to reduce need to satisfy in order to have the same result regardless on how reduce groups the applications of the operation f to the elements of the data structure? Prove that your function f indeed satisfies that property. | Functional interpretations also provide a way to extract constructive information from proofs in the reduced theory. As a direct consequence of the interpretation one usually obtains the result that any recursive function whose totality can be proven either in I or in C is represented by a term of F. If one can provide... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
To support very large scale neural networks in limited amount of memory, one may want to use floating point numbers with very few bits. Here we consider substantially simplified operations on such numbers, Float8. A value Float8(mant,exp) represents the non-negative integer mant * 2^exp. We call mant a mantissa (which ... | A 2-bit float with 1-bit exponent and 1-bit mantissa would only have 0, 1, Inf, NaN values. If the mantissa is allowed to be 0-bit, a 1-bit float format would have a 1-bit exponent, and the only two values would be 0 and Inf. The exponent must be at least 1 bit or else it no longer makes sense as a float (it would just... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
To support very large scale neural networks in limited amount of memory, one may want to use floating point numbers with very few bits. Here we consider substantially simplified operations on such numbers, Float8. A value Float8(mant,exp) represents the non-negative integer mant * 2^exp. We call mant a mantissa (which ... | NaN values have the highest exponent, with a non-zero value for the mantissa. A float with 1-bit sign and 3-bit mantissa has 2 × ( 2 3 − 1 ) = 14 {\displaystyle 2\times (2^{3}-1)=14} NaN values. s 1111 mmm = NaN (if mmm ≠ 000) | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2,y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. Define an operation hull2 that takes t... | Let C be a set of n axis-parallel rectangles in the plane. The following algorithm finds a disjoint set with a size of at least | M D S ( C ) | log n {\displaystyle {\frac {|MDS(C)|}{\log {n}}}} in time O ( n log n ) {\displaystyle O(n\log {n})}: INITIALIZATION: sort the horizontal edges of the given rectangles by ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
We have a collection of rectangles in a plane, whose sides are aligned with the coordinate axes. Each rectangle is represented by its lower left corner $(x_1,y_1)$ and its upper right corner $(x_2,y_2)$. All coordinates are of type Long. We require $x_1 \le x_2$ and $y_1 \le y_2$. Define an operation hull2 that takes t... | In this variant, there are multiple instances of a single rectangle of size (l,w), and a bigger rectangle of size (L,W). The goal is to pack as many small rectangles as possible into the big rectangle without overlap between any rectangles (small or large). Common constraints of the problem include limiting small recta... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Review the notion of depth seen in the lecture. What does it represent? Below is a formula for the depth of a divide and conquer algorithm working on an array segment of size $L$, as a function of $L$. The values $c$, $d$ and $T$ are constants. We assume that $L>0$ and $T>0$. $$ D(L) = \begin{cases} c \cdot L &\text{i... | The separator phase of the algorithm breaks the graph into components which are at most 1 / 2 {\displaystyle 1/2} the size of the original graph, resulting in a logarithmic recursion depth. At each level of the recursion, only linear work is needed to identify the separators as well as the connections possible between ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Review the notion of depth seen in the lecture. What does it represent? Below is a formula for the depth of a divide and conquer algorithm working on an array segment of size $L$, as a function of $L$. The values $c$, $d$ and $T$ are constants. We assume that $L>0$ and $T>0$. $$ D(L) = \begin{cases} c \cdot L &\text{i... | In the most balanced case, each time we perform a partition we divide the list into two nearly equal pieces. This means each recursive call processes a list of half the size. Consequently, we can make only log2 n nested calls before we reach a list of size 1. This means that the depth of the call tree is log2 n. But no... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Implement aggregate using the ... | There are no readily available heuristics available that are accurate with large databases. This method has only been used by Ringe's group.In these two methods there are often several trees found with the same score so the usual practice is to find a consensus tree via an algorithm. A majority consensus has bipartitio... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In this week's lecture, you have been introduced to the aggregate method of ParSeq[A] (and other parallel data structures). It has the following signature: def aggregate[B](z: B)(f: (B, A) => B, g: (B, B) => B): B Discuss, as a group, what aggregate does and what its arguments represent. Implement aggregate using the ... | The elements of aggregates (SET, BAG, LIST, ARRAY) are given in parentheses, separated by ",". Care has to be taken for select data types based on defined data types. Here the name of the defined data type gets mapped too. See also "Mapping of Express to Java" for more details of this. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which flag prevents user programs from reading and writing kernel data? | However, this variant requires that the operating system itself be prevented from writing to read-only pages (through the setting of a global processor flag), and not all kernels are designed this way; more recent kernels in fact are, since this is the same basic mechanism used for implementing copy-on-write. Additiona... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Which flag prevents user programs from reading and writing kernel data? | These programs do not run under the control of an operating system | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In JOS, after finishing the execution of a user-level page fault handler, how is the program control flow transferred back to the program? (You may get insights from the code snippet of _pagefault_upcall.) | Some interrupts are handled transparently to the program - for example, the normal resolution of a page fault is to make the required page accessible in physical memory. But in other cases such as a segmentation fault the operating system executes a process callback. On Unix-like operating systems this involves sending... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In JOS, after finishing the execution of a user-level page fault handler, how is the program control flow transferred back to the program? (You may get insights from the code snippet of _pagefault_upcall.) | Fault are induced by signals in POSIX compliant systems, and these signals originate from API calls, from the operating system, and from other applications. Any signal that does not have handler code becomes a fault that causes premature application termination. The handler is a function that is performed on-demand whe... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the content of the superblock in the JOS file system? | The superblock maintains information about the entire file system and includes the following fields: Size of the file system Number of data blocks in the file system A flag indicating the state of the file system Allocation group sizes File system block size | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
What is the content of the superblock in the JOS file system? | The Berkeley Fast File System superblock format is identified as either 19 54 01 19 or 01 19 54 depending on version; both represent the birthday of the author, Marshall Kirk McKusick. The Master Boot Record of bootable storage devices on almost all IA-32 IBM PC compatibles has a code of 55 AA as its last two bytes. Ex... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider an operation we will call scanRight1 that, given a function $f$ of two arguments, and a sequence $a_1, \ldots, a_N$, computes a sequence $b_1, \ldots, b_N$ such that: $b_N = a_N$ $b_i = f(a_{i}, b_{i+1})$, for $0 < i < N$ Define similarly scanLeft1 in a manner similar to scanRight1: Given a function $f$ of t... | Were the function f to refer to its second argument first here, and be able to produce some part of its result without reference to the recursive case (here, on its left i.e., in its first argument), then the recursion would stop. This means that while foldr recurses on the right, it allows for a lazy combining functio... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Consider an operation we will call scanRight1 that, given a function $f$ of two arguments, and a sequence $a_1, \ldots, a_N$, computes a sequence $b_1, \ldots, b_N$ such that: $b_N = a_N$ $b_i = f(a_{i}, b_{i+1})$, for $0 < i < N$ Define similarly scanLeft1 in a manner similar to scanRight1: Given a function $f$ of t... | Let V, R, and O be types, and i be any natural number, representing a sequence of parameters taken from V. Then the function sequence f of functions fn from Vi+n → R to O is defined by bar recursion from the functions Ln: R → O and B with Bn: ((Vi+n → R) x (Vn → R)) → O if: fn((λα:Vi+n)r) = Ln(r) for any r long enough ... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Freshly graduated from EPFL, you have been hired as contractors for a successful and rapidly growing bank. The bank has been experiencing problems with their money management system recently, which is written in Scala, and so they hired the best and brightest young engineer they could find: you! The system had been wor... | One of lock-based programming's biggest problems is that "locks don't compose": it is hard to combine small, correct lock-based modules into equally correct larger programs without modifying the modules or at least knowing about their internals. Simon Peyton Jones (an advocate of software transactional memory) gives th... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Freshly graduated from EPFL, you have been hired as contractors for a successful and rapidly growing bank. The bank has been experiencing problems with their money management system recently, which is written in Scala, and so they hired the best and brightest young engineer they could find: you! The system had been wor... | If line 3 in both operations executes before line 5 both operations will find that balance >= withdrawal evaluates to true, and execution will proceed to subtracting the withdrawal amount. However, since both processes perform their withdrawals, the total amount withdrawn will end up being more than the original balanc... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In which of the following cases does the TLB need to be flushed? | Flushing of the TLB can be an important security mechanism for memory isolation between processes to ensure a process can't access data stored in memory pages of another process. Memory isolation is especially critical during switches between the privileged operating system kernel process and the user processes – as wa... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In which of the following cases does the TLB need to be flushed? | On an address-space switch, as occurs when context switching between processes (but not between threads), some TLB entries can become invalid, since the virtual-to-physical mapping is different. The simplest strategy to deal with this is to completely flush the TLB. This means that after a switch, the TLB is empty, and... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select all valid answers about UNIX-like shell. | sqsh, a shell available with some SQL implementations for database queries and other tasks. Google Shell, a browser-based front-end for Google Search | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Select all valid answers about UNIX-like shell. | Many later command-line interpreters have been inspired by the Unix shell. A fundamental simplifying assumption of Unix was its focus on newline-delimited text for nearly all file formats. There were no "binary" editors in the original version of Unix – the entire system was configured using textual shell command scrip... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Review the notion of depth seen in the lecture. What does it represent? Below is a formula for the depth of a divide and conquer algorithm working on an array segment of size $L$, as a function of $L$. The values $c$, $d$ and $T$ are constants. We assume that $L>0$ and $T>0$. $$ D(L) = \begin{cases} c \cdot L &\text{... | The depth (defined as the maximal length of a regular M-sequence; also referred to as the grade of M) provides a sharp lower bound, i.e., it is the smallest integer n such that H I n ( M ) ≠ 0. {\displaystyle H_{I}^{n}(M)\neq 0.} These two bounds together yield a characterisation of Cohen–Macaulay modules over local ri... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Review the notion of depth seen in the lecture. What does it represent? Below is a formula for the depth of a divide and conquer algorithm working on an array segment of size $L$, as a function of $L$. The values $c$, $d$ and $T$ are constants. We assume that $L>0$ and $T>0$. $$ D(L) = \begin{cases} c \cdot L &\text{... | For computing ⌊ n ⌋ {\displaystyle \lfloor {\sqrt {n}}\rfloor } for very large integers n, one can use the quotient of Euclidean division for both of the division operations. This has the advantage of only using integers for each intermediate value, thus making the use of floating point representations of large numbers... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In x86, select all synchronous exceptions? | Asynchronous exceptions are events raised by a separate thread or external process, such as pressing Ctrl-C to interrupt a program, receiving a signal, or sending a disruptive message such as "stop" or "suspend" from another thread of execution. Whereas synchronous exceptions happen at a specific throw statement, async... | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
In x86, select all synchronous exceptions? | Structured exception handling. Proceedings of the 2nd ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL '75. pp. | https://www.kaggle.com/datasets/conjuring92/wiki-stem-corpus |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.